]> git.ipfire.org Git - thirdparty/mdadm.git/blob - super1.c
projects / thirdparty / mdadm.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Grow: be careful of corrupt dev_roles list
[thirdparty/mdadm.git] / super1.c
1 /*
2 * mdadm - manage Linux "md" devices aka RAID arrays.
3 *
4 * Copyright (C) 2001-2016 Neil Brown <neilb@suse.com>
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 <stddef.h>
26 #include "mdadm.h"
27 /*
28 * The version-1 superblock :
29 * All numeric fields are little-endian.
30 *
31 * total size: 256 bytes plus 2 per device.
32 * 1K allows 384 devices.
33 */
34 struct mdp_superblock_1 {
35 /* constant array information - 128 bytes */
36 __u32 magic; /* MD_SB_MAGIC: 0xa92b4efc - little endian */
37 __u32 major_version; /* 1 */
38 __u32 feature_map; /* 0 for now */
39 __u32 pad0; /* always set to 0 when writing */
40
41 __u8 set_uuid[16]; /* user-space generated. */
42 char set_name[32]; /* set and interpreted by user-space */
43
44 __u64 ctime; /* lo 40 bits are seconds, top 24 are microseconds or 0*/
45 __u32 level; /* -4 (multipath), -1 (linear), 0,1,4,5 */
46 __u32 layout; /* used for raid5, raid6, raid10, and raid0 */
47 __u64 size; /* used size of component devices, in 512byte sectors */
48
49 __u32 chunksize; /* in 512byte sectors */
50 __u32 raid_disks;
51 union {
52 __u32 bitmap_offset; /* sectors after start of superblock that bitmap starts
53 * NOTE: signed, so bitmap can be before superblock
54 * only meaningful of feature_map[0] is set.
55 */
56
57 /* only meaningful when feature_map[MD_FEATURE_PPL] is set */
58 struct {
59 __s16 offset; /* sectors from start of superblock that ppl starts */
60 __u16 size; /* ppl size in sectors */
61 } ppl;
62 };
63
64 /* These are only valid with feature bit '4' */
65 __u32 new_level; /* new level we are reshaping to */
66 __u64 reshape_position; /* next address in array-space for reshape */
67 __u32 delta_disks; /* change in number of raid_disks */
68 __u32 new_layout; /* new layout */
69 __u32 new_chunk; /* new chunk size (sectors) */
70 __u32 new_offset; /* signed number to add to data_offset in new
71 * layout. 0 == no-change. This can be
72 * different on each device in the array.
73 */
74
75 /* constant this-device information - 64 bytes */
76 __u64 data_offset; /* sector start of data, often 0 */
77 __u64 data_size; /* sectors in this device that can be used for data */
78 __u64 super_offset; /* sector start of this superblock */
79 union {
80 __u64 recovery_offset;/* sectors before this offset (from data_offset) have been recovered */
81 __u64 journal_tail;/* journal tail of journal device (from data_offset) */
82 };
83 __u32 dev_number; /* permanent identifier of this device - not role in raid */
84 __u32 cnt_corrected_read; /* number of read errors that were corrected by re-writing */
85 __u8 device_uuid[16]; /* user-space setable, ignored by kernel */
86 __u8 devflags; /* per-device flags. Only one defined...*/
87 #define WriteMostly1 1 /* mask for writemostly flag in above */
88 #define FailFast1 2 /* Device should get FailFast requests */
89 /* bad block log. If there are any bad blocks the feature flag is set.
90 * if offset and size are non-zero, that space is reserved and available.
91 */
92 __u8 bblog_shift; /* shift from sectors to block size for badblock list */
93 __u16 bblog_size; /* number of sectors reserved for badblock list */
94 __u32 bblog_offset; /* sector offset from superblock to bblog, signed */
95
96 /* array state information - 64 bytes */
97 __u64 utime; /* 40 bits second, 24 bits microseconds */
98 __u64 events; /* incremented when superblock updated */
99 __u64 resync_offset; /* data before this offset (from data_offset) known to be in sync */
100 __u32 sb_csum; /* checksum upto dev_roles[max_dev] */
101 __u32 max_dev; /* size of dev_roles[] array to consider */
102 __u8 pad3[64-32]; /* set to 0 when writing */
103
104 /* device state information. Indexed by dev_number.
105 * 2 bytes per device
106 * Note there are no per-device state flags. State information is rolled
107 * into the 'roles' value. If a device is spare or faulty, then it doesn't
108 * have a meaningful role.
109 */
110 __u16 dev_roles[0]; /* role in array, or 0xffff for a spare, or 0xfffe for faulty */
111 };
112
113 #define MAX_SB_SIZE 4096
114 /* bitmap super size is 256, but we round up to a sector for alignment */
115 #define BM_SUPER_SIZE 512
116 #define MAX_DEVS ((int)(MAX_SB_SIZE - sizeof(struct mdp_superblock_1)) / 2)
117 #define SUPER1_SIZE (MAX_SB_SIZE + BM_SUPER_SIZE \
118 + sizeof(struct misc_dev_info))
119
120 struct misc_dev_info {
121 __u64 device_size;
122 };
123
124 #define MULTIPLE_PPL_AREA_SIZE_SUPER1 (1024 * 1024) /* Size of the whole
125 * mutliple PPL area
126 */
127 /* feature_map bits */
128 #define MD_FEATURE_BITMAP_OFFSET 1
129 #define MD_FEATURE_RECOVERY_OFFSET 2 /* recovery_offset is present and
130 * must be honoured
131 */
132 #define MD_FEATURE_RESHAPE_ACTIVE 4
133 #define MD_FEATURE_BAD_BLOCKS 8 /* badblock list is not empty */
134 #define MD_FEATURE_REPLACEMENT 16 /* This device is replacing an
135 * active device with same 'role'.
136 * 'recovery_offset' is also set.
137 */
138 #define MD_FEATURE_RESHAPE_BACKWARDS 32 /* Reshape doesn't change number
139 * of devices, but is going
140 * backwards anyway.
141 */
142 #define MD_FEATURE_NEW_OFFSET 64 /* new_offset must be honoured */
143 #define MD_FEATURE_BITMAP_VERSIONED 256 /* bitmap version number checked properly */
144 #define MD_FEATURE_JOURNAL 512 /* support write journal */
145 #define MD_FEATURE_PPL 1024 /* support PPL */
146 #define MD_FEATURE_MUTLIPLE_PPLS 2048 /* support for multiple PPLs */
147 #define MD_FEATURE_RAID0_LAYOUT 4096 /* layout is meaningful in RAID0 */
148 #define MD_FEATURE_ALL (MD_FEATURE_BITMAP_OFFSET \
149 |MD_FEATURE_RECOVERY_OFFSET \
150 |MD_FEATURE_RESHAPE_ACTIVE \
151 |MD_FEATURE_BAD_BLOCKS \
152 |MD_FEATURE_REPLACEMENT \
153 |MD_FEATURE_RESHAPE_BACKWARDS \
154 |MD_FEATURE_NEW_OFFSET \
155 |MD_FEATURE_BITMAP_VERSIONED \
156 |MD_FEATURE_JOURNAL \
157 |MD_FEATURE_PPL \
158 |MD_FEATURE_MULTIPLE_PPLS \
159 |MD_FEATURE_RAID0_LAYOUT \
160 )
161
162 static int role_from_sb(struct mdp_superblock_1 *sb)
163 {
164 unsigned int d;
165 int role;
166
167 d = __le32_to_cpu(sb->dev_number);
168 if (d < __le32_to_cpu(sb->max_dev))
169 role = __le16_to_cpu(sb->dev_roles[d]);
170 else
171 role = MD_DISK_ROLE_SPARE;
172 return role;
173 }
174
175 /* return how many bytes are needed for bitmap, for cluster-md each node
176 * should have it's own bitmap */
177 static unsigned int calc_bitmap_size(bitmap_super_t *bms, unsigned int boundary)
178 {
179 unsigned long long bits, bytes;
180
181 bits = bitmap_bits(__le64_to_cpu(bms->sync_size),
182 __le32_to_cpu(bms->chunksize));
183 bytes = (bits+7) >> 3;
184 bytes += sizeof(bitmap_super_t);
185 bytes = ROUND_UP(bytes, boundary);
186
187 return bytes;
188 }
189
190 static unsigned int calc_sb_1_csum(struct mdp_superblock_1 * sb)
191 {
192 unsigned int disk_csum, csum;
193 unsigned long long newcsum;
194 int size = sizeof(*sb) + __le32_to_cpu(sb->max_dev)*2;
195 unsigned int *isuper = (unsigned int*)sb;
196
197 /* make sure I can count... */
198 if (offsetof(struct mdp_superblock_1,data_offset) != 128 ||
199 offsetof(struct mdp_superblock_1, utime) != 192 ||
200 sizeof(struct mdp_superblock_1) != 256) {
201 fprintf(stderr, "WARNING - superblock isn't sized correctly\n");
202 }
203
204 disk_csum = sb->sb_csum;
205 sb->sb_csum = 0;
206 newcsum = 0;
207 for (; size>=4; size -= 4 ) {
208 newcsum += __le32_to_cpu(*isuper);
209 isuper++;
210 }
211
212 if (size == 2)
213 newcsum += __le16_to_cpu(*(unsigned short*) isuper);
214
215 csum = (newcsum & 0xffffffff) + (newcsum >> 32);
216 sb->sb_csum = disk_csum;
217 return __cpu_to_le32(csum);
218 }
219
220 /*
221 * Information related to file descriptor used for aligned reads/writes.
222 * Cache the block size.
223 */
224 struct align_fd {
225 int fd;
226 int blk_sz;
227 };
228
229 static void init_afd(struct align_fd *afd, int fd)
230 {
231 afd->fd = fd;
232 if (!get_dev_sector_size(afd->fd, NULL, (unsigned int *)&afd->blk_sz))
233 afd->blk_sz = 512;
234 }
235
236 static char abuf[4096+4096];
237
238 static int aread(struct align_fd *afd, void *buf, int len)
239 {
240 /* aligned read.
241 * On devices with a 4K sector size, we need to read
242 * the full sector and copy relevant bits into
243 * the buffer
244 */
245 int bsize, iosize;
246 char *b;
247 int n;
248
249 bsize = afd->blk_sz;
250
251 if (!bsize || bsize > 4096 || len > 4096) {
252 if (!bsize)
253 fprintf(stderr, "WARNING - aread() called with invalid block size\n");
254 return -1;
255 }
256 b = ROUND_UP_PTR((char *)abuf, 4096);
257
258 for (iosize = 0; iosize < len; iosize += bsize)
259 ;
260 n = read(afd->fd, b, iosize);
261 if (n <= 0)
262 return n;
263 lseek(afd->fd, len - n, 1);
264 if (n > len)
265 n = len;
266 memcpy(buf, b, n);
267 return n;
268 }
269
270 static int awrite(struct align_fd *afd, void *buf, int len)
271 {
272 /* aligned write.
273 * On devices with a 4K sector size, we need to write
274 * the full sector. We pre-read if the sector is larger
275 * than the write.
276 * The address must be sector-aligned.
277 */
278 int bsize, iosize;
279 char *b;
280 int n;
281
282 bsize = afd->blk_sz;
283 if (!bsize || bsize > 4096 || len > 4096) {
284 if (!bsize)
285 fprintf(stderr, "WARNING - awrite() called with invalid block size\n");
286 return -1;
287 }
288 b = ROUND_UP_PTR((char *)abuf, 4096);
289
290 for (iosize = 0; iosize < len ; iosize += bsize)
291 ;
292
293 if (len != iosize) {
294 n = read(afd->fd, b, iosize);
295 if (n <= 0)
296 return n;
297 lseek(afd->fd, -n, 1);
298 }
299
300 memcpy(b, buf, len);
301 n = write(afd->fd, b, iosize);
302 if (n <= 0)
303 return n;
304 lseek(afd->fd, len - n, 1);
305 return len;
306 }
307
308 static inline unsigned int md_feature_any_ppl_on(__u32 feature_map)
309 {
310 return ((__cpu_to_le32(feature_map) &
311 (MD_FEATURE_PPL | MD_FEATURE_MUTLIPLE_PPLS)));
312 }
313
314 static inline unsigned int choose_ppl_space(int chunk)
315 {
316 return (PPL_HEADER_SIZE >> 9) + (chunk > 128*2 ? chunk : 128*2);
317 }
318
319 static void examine_super1(struct supertype *st, char *homehost)
320 {
321 struct mdp_superblock_1 *sb = st->sb;
322 bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb)+MAX_SB_SIZE);
323 time_t atime;
324 unsigned int d;
325 int role;
326 int delta_extra = 0;
327 int i;
328 char *c;
329 int l = homehost ? strlen(homehost) : 0;
330 int layout;
331 unsigned long long sb_offset;
332 struct mdinfo info;
333 int inconsistent = 0;
334
335 printf(" Magic : %08x\n", __le32_to_cpu(sb->magic));
336 printf(" Version : 1");
337 sb_offset = __le64_to_cpu(sb->super_offset);
338 if (sb_offset <= 4)
339 printf(".1\n");
340 else if (sb_offset <= 8)
341 printf(".2\n");
342 else
343 printf(".0\n");
344 printf(" Feature Map : 0x%x\n", __le32_to_cpu(sb->feature_map));
345 printf(" Array UUID : ");
346 for (i=0; i<16; i++) {
347 if ((i&3)==0 && i != 0) printf(":");
348 printf("%02x", sb->set_uuid[i]);
349 }
350 printf("\n");
351 printf(" Name : %.32s", sb->set_name);
352 if (l > 0 && l < 32 &&
353 sb->set_name[l] == ':' &&
354 strncmp(sb->set_name, homehost, l) == 0)
355 printf(" (local to host %s)", homehost);
356 printf("\n");
357 if (bms->nodes > 0 &&
358 (__le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET))
359 printf(" Cluster Name : %-64s\n", bms->cluster_name);
360 atime = __le64_to_cpu(sb->ctime) & 0xFFFFFFFFFFULL;
361 printf(" Creation Time : %.24s\n", ctime(&atime));
362 c=map_num(pers, __le32_to_cpu(sb->level));
363 printf(" Raid Level : %s\n", c?c:"-unknown-");
364 printf(" Raid Devices : %d\n", __le32_to_cpu(sb->raid_disks));
365 printf("\n");
366 printf(" Avail Dev Size : %llu sectors%s\n",
367 (unsigned long long)__le64_to_cpu(sb->data_size),
368 human_size(__le64_to_cpu(sb->data_size)<<9));
369 if (__le32_to_cpu(sb->level) > 0) {
370 int ddsks = 0, ddsks_denom = 1;
371 switch(__le32_to_cpu(sb->level)) {
372 case 1: ddsks=1;break;
373 case 4:
374 case 5: ddsks = __le32_to_cpu(sb->raid_disks)-1; break;
375 case 6: ddsks = __le32_to_cpu(sb->raid_disks)-2; break;
376 case 10:
377 layout = __le32_to_cpu(sb->layout);
378 ddsks = __le32_to_cpu(sb->raid_disks);
379 ddsks_denom = (layout&255) * ((layout>>8)&255);
380 }
381 if (ddsks) {
382 long long asize = __le64_to_cpu(sb->size);
383 asize = (asize << 9) * ddsks / ddsks_denom;
384 printf(" Array Size : %llu KiB%s\n",
385 asize >> 10, human_size(asize));
386 }
387 if (sb->size != sb->data_size)
388 printf(" Used Dev Size : %llu sectors%s\n",
389 (unsigned long long)__le64_to_cpu(sb->size),
390 human_size(__le64_to_cpu(sb->size)<<9));
391 }
392 if (sb->data_offset)
393 printf(" Data Offset : %llu sectors\n",
394 (unsigned long long)__le64_to_cpu(sb->data_offset));
395 if (sb->new_offset &&
396 (__le32_to_cpu(sb->feature_map) & MD_FEATURE_NEW_OFFSET)) {
397 unsigned long long offset = __le64_to_cpu(sb->data_offset);
398 offset += (signed)(int32_t)__le32_to_cpu(sb->new_offset);
399 printf(" New Offset : %llu sectors\n", offset);
400 }
401 printf(" Super Offset : %llu sectors\n",
402 (unsigned long long)__le64_to_cpu(sb->super_offset));
403 if (__le32_to_cpu(sb->feature_map) & MD_FEATURE_RECOVERY_OFFSET)
404 printf("Recovery Offset : %llu sectors\n",
405 (unsigned long long)__le64_to_cpu(sb->recovery_offset));
406
407 st->ss->getinfo_super(st, &info, NULL);
408 if (info.space_after != 1 &&
409 !(__le32_to_cpu(sb->feature_map) & MD_FEATURE_NEW_OFFSET))
410 printf(" Unused Space : before=%llu sectors, after=%llu sectors\n",
411 info.space_before, info.space_after);
412
413 printf(" State : %s\n",
414 (__le64_to_cpu(sb->resync_offset)+1)? "active":"clean");
415 printf(" Device UUID : ");
416 for (i=0; i<16; i++) {
417 if ((i&3)==0 && i != 0)
418 printf(":");
419 printf("%02x", sb->device_uuid[i]);
420 }
421 printf("\n");
422 printf("\n");
423 if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BITMAP_OFFSET)) {
424 printf("Internal Bitmap : %ld sectors from superblock\n",
425 (long)(int32_t)__le32_to_cpu(sb->bitmap_offset));
426 } else if (md_feature_any_ppl_on(sb->feature_map)) {
427 printf(" PPL : %u sectors at offset %d sectors from superblock\n",
428 __le16_to_cpu(sb->ppl.size),
429 __le16_to_cpu(sb->ppl.offset));
430 }
431 if (sb->feature_map & __cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE)) {
432 printf(" Reshape pos'n : %llu%s\n", (unsigned long long)
433 __le64_to_cpu(sb->reshape_position)/2,
434 human_size(__le64_to_cpu(sb->reshape_position)<<9));
435 if (__le32_to_cpu(sb->delta_disks)) {
436 printf(" Delta Devices : %d",
437 __le32_to_cpu(sb->delta_disks));
438 printf(" (%d->%d)\n",
439 __le32_to_cpu(sb->raid_disks) -
440 __le32_to_cpu(sb->delta_disks),
441 __le32_to_cpu(sb->raid_disks));
442 if ((int)__le32_to_cpu(sb->delta_disks) < 0)
443 delta_extra = -__le32_to_cpu(sb->delta_disks);
444 }
445 if (__le32_to_cpu(sb->new_level) != __le32_to_cpu(sb->level)) {
446 c = map_num(pers, __le32_to_cpu(sb->new_level));
447 printf(" New Level : %s\n", c?c:"-unknown-");
448 }
449 if (__le32_to_cpu(sb->new_layout) !=
450 __le32_to_cpu(sb->layout)) {
451 if (__le32_to_cpu(sb->level) == 5) {
452 c = map_num(r5layout,
453 __le32_to_cpu(sb->new_layout));
454 printf(" New Layout : %s\n", c?c:"-unknown-");
455 }
456 if (__le32_to_cpu(sb->level) == 6) {
457 c = map_num(r6layout,
458 __le32_to_cpu(sb->new_layout));
459 printf(" New Layout : %s\n", c?c:"-unknown-");
460 }
461 if (__le32_to_cpu(sb->level) == 10) {
462 printf(" New Layout :");
463 print_r10_layout(__le32_to_cpu(sb->new_layout));
464 printf("\n");
465 }
466 }
467 if (__le32_to_cpu(sb->new_chunk) !=
468 __le32_to_cpu(sb->chunksize))
469 printf(" New Chunksize : %dK\n",
470 __le32_to_cpu(sb->new_chunk)/2);
471 printf("\n");
472 }
473 if (sb->devflags) {
474 printf(" Flags :");
475 if (sb->devflags & WriteMostly1)
476 printf(" write-mostly");
477 if (sb->devflags & FailFast1)
478 printf(" failfast");
479 printf("\n");
480 }
481
482 atime = __le64_to_cpu(sb->utime) & 0xFFFFFFFFFFULL;
483 printf(" Update Time : %.24s\n", ctime(&atime));
484
485 if (sb->bblog_size && sb->bblog_offset) {
486 printf(" Bad Block Log : %d entries available at offset %ld sectors",
487 __le16_to_cpu(sb->bblog_size)*512/8,
488 (long)(int32_t)__le32_to_cpu(sb->bblog_offset));
489 if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BAD_BLOCKS))
490 printf(" - bad blocks present.");
491 printf("\n");
492 }
493
494 if (calc_sb_1_csum(sb) == sb->sb_csum)
495 printf(" Checksum : %x - correct\n",
496 __le32_to_cpu(sb->sb_csum));
497 else
498 printf(" Checksum : %x - expected %x\n",
499 __le32_to_cpu(sb->sb_csum),
500 __le32_to_cpu(calc_sb_1_csum(sb)));
501 printf(" Events : %llu\n",
502 (unsigned long long)__le64_to_cpu(sb->events));
503 printf("\n");
504 if (__le32_to_cpu(sb->level) == 0 &&
505 (sb->feature_map & __cpu_to_le32(MD_FEATURE_RAID0_LAYOUT))) {
506 c = map_num(r0layout, __le32_to_cpu(sb->layout));
507 printf(" Layout : %s\n", c?c:"-unknown-");
508 }
509 if (__le32_to_cpu(sb->level) == 5) {
510 c = map_num(r5layout, __le32_to_cpu(sb->layout));
511 printf(" Layout : %s\n", c?c:"-unknown-");
512 }
513 if (__le32_to_cpu(sb->level) == 6) {
514 c = map_num(r6layout, __le32_to_cpu(sb->layout));
515 printf(" Layout : %s\n", c?c:"-unknown-");
516 }
517 if (__le32_to_cpu(sb->level) == 10) {
518 int lo = __le32_to_cpu(sb->layout);
519 printf(" Layout :");
520 print_r10_layout(lo);
521 printf("\n");
522 }
523 switch(__le32_to_cpu(sb->level)) {
524 case 0:
525 case 4:
526 case 5:
527 case 6:
528 case 10:
529 printf(" Chunk Size : %dK\n",
530 __le32_to_cpu(sb->chunksize)/2);
531 break;
532 case -1:
533 printf(" Rounding : %dK\n",
534 __le32_to_cpu(sb->chunksize)/2);
535 break;
536 default:
537 break;
538 }
539 printf("\n");
540 #if 0
541 /* This turns out to just be confusing */
542 printf(" Array Slot : %d (", __le32_to_cpu(sb->dev_number));
543 for (i = __le32_to_cpu(sb->max_dev); i> 0 ; i--)
544 if (__le16_to_cpu(sb->dev_roles[i-1]) != MD_DISK_ROLE_SPARE)
545 break;
546 for (d = 0; d < i; d++) {
547 int role = __le16_to_cpu(sb->dev_roles[d]);
548 if (d)
549 printf(", ");
550 if (role == MD_DISK_ROLE_SPARE)
551 printf("empty");
552 else
553 if(role == MD_DISK_ROLE_FAULTY)
554 printf("failed");
555 else
556 printf("%d", role);
557 }
558 printf(")\n");
559 #endif
560 printf(" Device Role : ");
561 role = role_from_sb(sb);
562 if (role >= MD_DISK_ROLE_FAULTY)
563 printf("spare\n");
564 else if (role == MD_DISK_ROLE_JOURNAL)
565 printf("Journal\n");
566 else if (sb->feature_map & __cpu_to_le32(MD_FEATURE_REPLACEMENT))
567 printf("Replacement device %d\n", role);
568 else
569 printf("Active device %d\n", role);
570
571 printf(" Array State : ");
572 for (d = 0; d < __le32_to_cpu(sb->raid_disks) + delta_extra; d++) {
573 int cnt = 0;
574 unsigned int i;
575 for (i = 0; i < __le32_to_cpu(sb->max_dev); i++) {
576 unsigned int role = __le16_to_cpu(sb->dev_roles[i]);
577 if (role == d)
578 cnt++;
579 }
580 if (cnt == 2 && __le32_to_cpu(sb->level) > 0)
581 printf("R");
582 else if (cnt == 1)
583 printf("A");
584 else if (cnt == 0)
585 printf(".");
586 else {
587 printf("?");
588 inconsistent = 1;
589 }
590 }
591 #if 0
592 /* This is confusing too */
593 faulty = 0;
594 for (i = 0; i< __le32_to_cpu(sb->max_dev); i++) {
595 int role = __le16_to_cpu(sb->dev_roles[i]);
596 if (role == MD_DISK_ROLE_FAULTY)
597 faulty++;
598 }
599 if (faulty)
600 printf(" %d failed", faulty);
601 #endif
602 printf(" ('A' == active, '.' == missing, 'R' == replacing)");
603 printf("\n");
604 for (d = 0; d < __le32_to_cpu(sb->max_dev); d++) {
605 unsigned int r = __le16_to_cpu(sb->dev_roles[d]);
606 if (r <= MD_DISK_ROLE_MAX &&
607 r > __le32_to_cpu(sb->raid_disks) + delta_extra)
608 inconsistent = 1;
609 }
610 if (inconsistent) {
611 printf("WARNING Array state is inconsistent - each number should appear only once\n");
612 for (d = 0; d < __le32_to_cpu(sb->max_dev); d++)
613 if (__le16_to_cpu(sb->dev_roles[d]) >= MD_DISK_ROLE_FAULTY)
614 printf(" %d:-", d);
615 else
616 printf(" %d:%d", d, __le16_to_cpu(sb->dev_roles[d]));
617 printf("\n");
618 }
619 }
620
621 static void brief_examine_super1(struct supertype *st, int verbose)
622 {
623 struct mdp_superblock_1 *sb = st->sb;
624 int i;
625 unsigned long long sb_offset;
626 char *nm;
627 char *c = map_num(pers, __le32_to_cpu(sb->level));
628
629 nm = strchr(sb->set_name, ':');
630 if (nm)
631 nm++;
632 else if (sb->set_name[0])
633 nm = sb->set_name;
634 else
635 nm = NULL;
636
637 printf("ARRAY ");
638 if (nm) {
639 printf("/dev/md/");
640 print_escape(nm);
641 putchar(' ');
642 }
643 if (verbose && c)
644 printf(" level=%s", c);
645 sb_offset = __le64_to_cpu(sb->super_offset);
646 if (sb_offset <= 4)
647 printf(" metadata=1.1 ");
648 else if (sb_offset <= 8)
649 printf(" metadata=1.2 ");
650 else
651 printf(" metadata=1.0 ");
652 if (verbose)
653 printf("num-devices=%d ", __le32_to_cpu(sb->raid_disks));
654 printf("UUID=");
655 for (i = 0; i < 16; i++) {
656 if ((i&3)==0 && i != 0)
657 printf(":");
658 printf("%02x", sb->set_uuid[i]);
659 }
660 if (sb->set_name[0]) {
661 printf(" name=");
662 print_quoted(sb->set_name);
663 }
664 printf("\n");
665 }
666
667 static void export_examine_super1(struct supertype *st)
668 {
669 struct mdp_superblock_1 *sb = st->sb;
670 int i;
671 int len = 32;
672 int layout;
673
674 printf("MD_LEVEL=%s\n", map_num(pers, __le32_to_cpu(sb->level)));
675 printf("MD_DEVICES=%d\n", __le32_to_cpu(sb->raid_disks));
676 for (i = 0; i < 32; i++)
677 if (sb->set_name[i] == '\n' || sb->set_name[i] == '\0') {
678 len = i;
679 break;
680 }
681 if (len)
682 printf("MD_NAME=%.*s\n", len, sb->set_name);
683 if (__le32_to_cpu(sb->level) > 0) {
684 int ddsks = 0, ddsks_denom = 1;
685 switch(__le32_to_cpu(sb->level)) {
686 case 1:
687 ddsks = 1;
688 break;
689 case 4:
690 case 5:
691 ddsks = __le32_to_cpu(sb->raid_disks)-1;
692 break;
693 case 6:
694 ddsks = __le32_to_cpu(sb->raid_disks)-2;
695 break;
696 case 10:
697 layout = __le32_to_cpu(sb->layout);
698 ddsks = __le32_to_cpu(sb->raid_disks);
699 ddsks_denom = (layout&255) * ((layout>>8)&255);
700 }
701 if (ddsks) {
702 long long asize = __le64_to_cpu(sb->size);
703 asize = (asize << 9) * ddsks / ddsks_denom;
704 printf("MD_ARRAY_SIZE=%s\n",
705 human_size_brief(asize, JEDEC));
706 }
707 }
708 printf("MD_UUID=");
709 for (i = 0; i < 16; i++) {
710 if ((i&3) == 0 && i != 0)
711 printf(":");
712 printf("%02x", sb->set_uuid[i]);
713 }
714 printf("\n");
715 printf("MD_UPDATE_TIME=%llu\n",
716 __le64_to_cpu(sb->utime) & 0xFFFFFFFFFFULL);
717 printf("MD_DEV_UUID=");
718 for (i = 0; i < 16; i++) {
719 if ((i&3) == 0 && i != 0)
720 printf(":");
721 printf("%02x", sb->device_uuid[i]);
722 }
723 printf("\n");
724 printf("MD_EVENTS=%llu\n",
725 (unsigned long long)__le64_to_cpu(sb->events));
726 }
727
728 static int copy_metadata1(struct supertype *st, int from, int to)
729 {
730 /* Read superblock. If it looks good, write it out.
731 * Then if a bitmap is present, copy that.
732 * And if a bad-block-list is present, copy that too.
733 */
734 void *buf;
735 unsigned long long dsize, sb_offset;
736 const int bufsize = 4*1024;
737 struct mdp_superblock_1 super, *sb;
738
739 if (posix_memalign(&buf, 4096, bufsize) != 0)
740 return 1;
741
742 if (!get_dev_size(from, NULL, &dsize))
743 goto err;
744
745 dsize >>= 9;
746 if (dsize < 24)
747 goto err;
748 switch(st->minor_version) {
749 case 0:
750 sb_offset = dsize;
751 sb_offset -= 8*2;
752 sb_offset &= ~(4*2-1);
753 break;
754 case 1:
755 sb_offset = 0;
756 break;
757 case 2:
758 sb_offset = 4*2;
759 break;
760 default:
761 goto err;
762 }
763
764 if (lseek64(from, sb_offset << 9, 0) < 0LL)
765 goto err;
766 if (read(from, buf, bufsize) != bufsize)
767 goto err;
768
769 sb = buf;
770 super = *sb; // save most of sb for when we reuse buf
771
772 if (__le32_to_cpu(super.magic) != MD_SB_MAGIC ||
773 __le32_to_cpu(super.major_version) != 1 ||
774 __le64_to_cpu(super.super_offset) != sb_offset ||
775 calc_sb_1_csum(sb) != super.sb_csum)
776 goto err;
777
778 if (lseek64(to, sb_offset << 9, 0) < 0LL)
779 goto err;
780 if (write(to, buf, bufsize) != bufsize)
781 goto err;
782
783 if (super.feature_map & __le32_to_cpu(MD_FEATURE_BITMAP_OFFSET)) {
784 unsigned long long bitmap_offset = sb_offset;
785 int bytes = 4096; // just an estimate.
786 int written = 0;
787 struct align_fd afrom, ato;
788
789 init_afd(&afrom, from);
790 init_afd(&ato, to);
791
792 bitmap_offset += (int32_t)__le32_to_cpu(super.bitmap_offset);
793
794 if (lseek64(from, bitmap_offset<<9, 0) < 0)
795 goto err;
796 if (lseek64(to, bitmap_offset<<9, 0) < 0)
797 goto err;
798
799 for (written = 0; written < bytes ; ) {
800 int n = bytes - written;
801 if (n > 4096)
802 n = 4096;
803 if (aread(&afrom, buf, n) != n)
804 goto err;
805 if (written == 0) {
806 /* have the header, can calculate
807 * correct bitmap bytes */
808 bitmap_super_t *bms;
809 bms = (void*)buf;
810 bytes = calc_bitmap_size(bms, 512);
811 if (n > bytes)
812 n = bytes;
813 }
814 if (awrite(&ato, buf, n) != n)
815 goto err;
816 written += n;
817 }
818 }
819
820 if (super.bblog_size != 0 &&
821 __le16_to_cpu(super.bblog_size) <= 100 &&
822 super.bblog_offset != 0 &&
823 (super.feature_map & __le32_to_cpu(MD_FEATURE_BAD_BLOCKS))) {
824 /* There is a bad block log */
825 unsigned long long bb_offset = sb_offset;
826 int bytes = __le16_to_cpu(super.bblog_size) * 512;
827 int written = 0;
828 struct align_fd afrom, ato;
829
830 init_afd(&afrom, from);
831 init_afd(&ato, to);
832
833 bb_offset += (int32_t)__le32_to_cpu(super.bblog_offset);
834
835 if (lseek64(from, bb_offset<<9, 0) < 0)
836 goto err;
837 if (lseek64(to, bb_offset<<9, 0) < 0)
838 goto err;
839
840 for (written = 0; written < bytes ; ) {
841 int n = bytes - written;
842 if (n > 4096)
843 n = 4096;
844 if (aread(&afrom, buf, n) != n)
845 goto err;
846
847 if (awrite(&ato, buf, n) != n)
848 goto err;
849 written += n;
850 }
851 }
852
853 free(buf);
854 return 0;
855
856 err:
857 free(buf);
858 return 1;
859 }
860
861 static void detail_super1(struct supertype *st, char *homehost, char *subarray)
862 {
863 struct mdp_superblock_1 *sb = st->sb;
864 bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb) + MAX_SB_SIZE);
865 int i;
866 int l = homehost ? strlen(homehost) : 0;
867
868 printf(" Name : %.32s", sb->set_name);
869 if (l > 0 && l < 32 && sb->set_name[l] == ':' &&
870 strncmp(sb->set_name, homehost, l) == 0)
871 printf(" (local to host %s)", homehost);
872 if (bms->nodes > 0 &&
873 (__le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET))
874 printf("\n Cluster Name : %-64s", bms->cluster_name);
875 printf("\n UUID : ");
876 for (i = 0; i < 16; i++) {
877 if ((i&3) == 0 && i != 0)
878 printf(":");
879 printf("%02x", sb->set_uuid[i]);
880 }
881 printf("\n Events : %llu\n\n",
882 (unsigned long long)__le64_to_cpu(sb->events));
883 }
884
885 static void brief_detail_super1(struct supertype *st, char *subarray)
886 {
887 struct mdp_superblock_1 *sb = st->sb;
888 int i;
889
890 if (sb->set_name[0]) {
891 printf(" name=");
892 print_quoted(sb->set_name);
893 }
894 printf(" UUID=");
895 for (i = 0; i < 16; i++) {
896 if ((i & 3) == 0 && i != 0)
897 printf(":");
898 printf("%02x", sb->set_uuid[i]);
899 }
900 }
901
902 static void export_detail_super1(struct supertype *st)
903 {
904 struct mdp_superblock_1 *sb = st->sb;
905 int i;
906 int len = 32;
907
908 for (i = 0; i < 32; i++)
909 if (sb->set_name[i] == '\n' || sb->set_name[i] == '\0') {
910 len = i;
911 break;
912 }
913 if (len)
914 printf("MD_NAME=%.*s\n", len, sb->set_name);
915 }
916
917 static int examine_badblocks_super1(struct supertype *st, int fd, char *devname)
918 {
919 struct mdp_superblock_1 *sb = st->sb;
920 unsigned long long offset;
921 int size;
922 __u64 *bbl, *bbp;
923 int i;
924
925 if (!sb->bblog_size || __le16_to_cpu(sb->bblog_size) > 100 ||
926 !sb->bblog_offset){
927 printf("No bad-blocks list configured on %s\n", devname);
928 return 0;
929 }
930 if ((sb->feature_map & __cpu_to_le32(MD_FEATURE_BAD_BLOCKS)) == 0) {
931 printf("Bad-blocks list is empty in %s\n", devname);
932 return 0;
933 }
934
935 size = __le16_to_cpu(sb->bblog_size)* 512;
936 if (posix_memalign((void**)&bbl, 4096, size) != 0) {
937 pr_err("could not allocate badblocks list\n");
938 return 0;
939 }
940 offset = __le64_to_cpu(sb->super_offset) +
941 (int)__le32_to_cpu(sb->bblog_offset);
942 offset <<= 9;
943 if (lseek64(fd, offset, 0) < 0) {
944 pr_err("Cannot seek to bad-blocks list\n");
945 return 1;
946 }
947 if (read(fd, bbl, size) != size) {
948 pr_err("Cannot read bad-blocks list\n");
949 return 1;
950 }
951 /* 64bits per entry. 10 bits is block-count, 54 bits is block
952 * offset. Blocks are sectors unless bblog->shift makes them bigger
953 */
954 bbp = (__u64*)bbl;
955 printf("Bad-blocks on %s:\n", devname);
956 for (i = 0; i < size/8; i++, bbp++) {
957 __u64 bb = __le64_to_cpu(*bbp);
958 int count = bb & 0x3ff;
959 unsigned long long sector = bb >> 10;
960
961 if (bb + 1 == 0)
962 break;
963
964 sector <<= sb->bblog_shift;
965 count <<= sb->bblog_shift;
966
967 printf("%20llu for %d sectors\n", sector, count);
968 }
969 return 0;
970 }
971
972 static int match_home1(struct supertype *st, char *homehost)
973 {
974 struct mdp_superblock_1 *sb = st->sb;
975 int l = homehost ? strlen(homehost) : 0;
976
977 return (l > 0 && l < 32 && sb->set_name[l] == ':' &&
978 strncmp(sb->set_name, homehost, l) == 0);
979 }
980
981 static void uuid_from_super1(struct supertype *st, int uuid[4])
982 {
983 struct mdp_superblock_1 *super = st->sb;
984 char *cuuid = (char*)uuid;
985 int i;
986 for (i = 0; i < 16; i++)
987 cuuid[i] = super->set_uuid[i];
988 }
989
990 static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map)
991 {
992 struct mdp_superblock_1 *sb = st->sb;
993 struct bitmap_super_s *bsb = (void*)(((char*)sb)+MAX_SB_SIZE);
994 struct misc_dev_info *misc =
995 (void*)(((char*)sb)+MAX_SB_SIZE+BM_SUPER_SIZE);
996 int working = 0;
997 unsigned int i;
998 unsigned int role;
999 unsigned int map_disks = info->array.raid_disks;
1000 unsigned long long super_offset;
1001 unsigned long long data_size;
1002
1003 memset(info, 0, sizeof(*info));
1004 info->array.major_version = 1;
1005 info->array.minor_version = st->minor_version;
1006 info->array.patch_version = 0;
1007 info->array.raid_disks = __le32_to_cpu(sb->raid_disks);
1008 info->array.level = __le32_to_cpu(sb->level);
1009 info->array.layout = __le32_to_cpu(sb->layout);
1010 info->array.md_minor = -1;
1011 info->array.ctime = __le64_to_cpu(sb->ctime);
1012 info->array.utime = __le64_to_cpu(sb->utime);
1013 info->array.chunk_size = __le32_to_cpu(sb->chunksize)*512;
1014 info->array.state =
1015 (__le64_to_cpu(sb->resync_offset) == MaxSector) ? 1 : 0;
1016
1017 super_offset = __le64_to_cpu(sb->super_offset);
1018 info->data_offset = __le64_to_cpu(sb->data_offset);
1019 info->component_size = __le64_to_cpu(sb->size);
1020 if (sb->feature_map & __le32_to_cpu(MD_FEATURE_BITMAP_OFFSET)) {
1021 info->bitmap_offset = (int32_t)__le32_to_cpu(sb->bitmap_offset);
1022 if (__le32_to_cpu(bsb->nodes) > 1)
1023 info->array.state |= (1 << MD_SB_CLUSTERED);
1024 } else if (md_feature_any_ppl_on(sb->feature_map)) {
1025 info->ppl_offset = __le16_to_cpu(sb->ppl.offset);
1026 info->ppl_size = __le16_to_cpu(sb->ppl.size);
1027 info->ppl_sector = super_offset + info->ppl_offset;
1028 }
1029
1030 info->disk.major = 0;
1031 info->disk.minor = 0;
1032 info->disk.number = __le32_to_cpu(sb->dev_number);
1033 if (__le32_to_cpu(sb->dev_number) >= __le32_to_cpu(sb->max_dev) ||
1034 __le32_to_cpu(sb->dev_number) >= MAX_DEVS)
1035 role = MD_DISK_ROLE_FAULTY;
1036 else
1037 role = __le16_to_cpu(sb->dev_roles[__le32_to_cpu(sb->dev_number)]);
1038
1039 if (info->array.level <= 0)
1040 data_size = __le64_to_cpu(sb->data_size);
1041 else
1042 data_size = __le64_to_cpu(sb->size);
1043 if (info->data_offset < super_offset) {
1044 unsigned long long end;
1045 info->space_before = info->data_offset;
1046 end = super_offset;
1047
1048 if (sb->bblog_offset && sb->bblog_size) {
1049 unsigned long long bboffset = super_offset;
1050 bboffset += (int32_t)__le32_to_cpu(sb->bblog_offset);
1051 if (bboffset < end)
1052 end = bboffset;
1053 }
1054
1055 if (super_offset + info->bitmap_offset + info->ppl_offset < end)
1056 end = super_offset + info->bitmap_offset +
1057 info->ppl_offset;
1058
1059 if (info->data_offset + data_size < end)
1060 info->space_after = end - data_size - info->data_offset;
1061 else
1062 info->space_after = 0;
1063 } else {
1064 unsigned long long earliest;
1065 earliest = super_offset + (32+4)*2; /* match kernel */
1066 if (info->bitmap_offset > 0) {
1067 unsigned long long bmend = info->bitmap_offset;
1068 unsigned long long size = calc_bitmap_size(bsb, 4096);
1069 size /= 512;
1070 bmend += size;
1071 if (bmend > earliest)
1072 earliest = bmend;
1073 } else if (info->ppl_offset > 0) {
1074 unsigned long long pplend;
1075
1076 pplend = info->ppl_offset + info->ppl_size;
1077 if (pplend > earliest)
1078 earliest = pplend;
1079 }
1080 if (sb->bblog_offset && sb->bblog_size) {
1081 unsigned long long bbend = super_offset;
1082 bbend += (int32_t)__le32_to_cpu(sb->bblog_offset);
1083 bbend += __le16_to_cpu(sb->bblog_size);
1084 if (bbend > earliest)
1085 earliest = bbend;
1086 }
1087 if (earliest < info->data_offset)
1088 info->space_before = info->data_offset - earliest;
1089 else
1090 info->space_before = 0;
1091 info->space_after = misc->device_size - data_size -
1092 info->data_offset;
1093 }
1094 if (info->space_before == 0 && info->space_after == 0) {
1095 /* It will look like we don't support data_offset changes,
1096 * be we do - it's just that there is no room.
1097 * A change that reduced the number of devices should
1098 * still be allowed, so set the otherwise useless value of '1'
1099 */
1100 info->space_after = 1;
1101 }
1102
1103 info->disk.raid_disk = -1;
1104 switch(role) {
1105 case MD_DISK_ROLE_SPARE:
1106 /* spare: not active, not sync, not faulty */
1107 info->disk.state = 0;
1108 break;
1109 case MD_DISK_ROLE_FAULTY:
1110 info->disk.state = (1 << MD_DISK_FAULTY); /* faulty */
1111 break;
1112 case MD_DISK_ROLE_JOURNAL:
1113 info->disk.state = (1 << MD_DISK_JOURNAL);
1114 info->disk.raid_disk = role;
1115 /* journal uses all 4kB blocks*/
1116 info->space_after = (misc->device_size - info->data_offset) % 8;
1117 break;
1118 default:
1119 info->disk.state = 6; /* active and in sync */
1120 info->disk.raid_disk = role;
1121 }
1122 if (sb->devflags & WriteMostly1)
1123 info->disk.state |= (1 << MD_DISK_WRITEMOSTLY);
1124 if (sb->devflags & FailFast1)
1125 info->disk.state |= (1 << MD_DISK_FAILFAST);
1126 info->events = __le64_to_cpu(sb->events);
1127 sprintf(info->text_version, "1.%d", st->minor_version);
1128 info->safe_mode_delay = 200;
1129
1130 memcpy(info->uuid, sb->set_uuid, 16);
1131
1132 strncpy(info->name, sb->set_name, 32);
1133 info->name[32] = 0;
1134
1135 if ((__le32_to_cpu(sb->feature_map)&MD_FEATURE_REPLACEMENT)) {
1136 info->disk.state &= ~(1 << MD_DISK_SYNC);
1137 info->disk.state |= 1 << MD_DISK_REPLACEMENT;
1138 }
1139
1140 if (sb->feature_map & __le32_to_cpu(MD_FEATURE_RECOVERY_OFFSET))
1141 info->recovery_start = __le32_to_cpu(sb->recovery_offset);
1142 else
1143 info->recovery_start = MaxSector;
1144
1145 if (sb->feature_map & __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE)) {
1146 info->reshape_active = 1;
1147 if ((sb->feature_map & __le32_to_cpu(MD_FEATURE_NEW_OFFSET)) &&
1148 sb->new_offset != 0)
1149 info->reshape_active |= RESHAPE_NO_BACKUP;
1150 info->reshape_progress = __le64_to_cpu(sb->reshape_position);
1151 info->new_level = __le32_to_cpu(sb->new_level);
1152 info->delta_disks = __le32_to_cpu(sb->delta_disks);
1153 info->new_layout = __le32_to_cpu(sb->new_layout);
1154 info->new_chunk = __le32_to_cpu(sb->new_chunk)<<9;
1155 if (info->delta_disks < 0)
1156 info->array.raid_disks -= info->delta_disks;
1157 } else
1158 info->reshape_active = 0;
1159
1160 info->recovery_blocked = info->reshape_active;
1161
1162 if (map)
1163 for (i=0; i<map_disks; i++)
1164 map[i] = 0;
1165 for (i = 0; i < __le32_to_cpu(sb->max_dev); i++) {
1166 role = __le16_to_cpu(sb->dev_roles[i]);
1167 if (/*role == MD_DISK_ROLE_SPARE || */role < (unsigned) info->array.raid_disks) {
1168 working++;
1169 if (map && role < map_disks)
1170 map[role] = 1;
1171 }
1172 }
1173
1174 info->array.working_disks = working;
1175
1176 if (sb->feature_map & __le32_to_cpu(MD_FEATURE_JOURNAL)) {
1177 info->journal_device_required = 1;
1178 info->consistency_policy = CONSISTENCY_POLICY_JOURNAL;
1179 } else if (md_feature_any_ppl_on(sb->feature_map)) {
1180 info->consistency_policy = CONSISTENCY_POLICY_PPL;
1181 } else if (sb->feature_map & __le32_to_cpu(MD_FEATURE_BITMAP_OFFSET)) {
1182 info->consistency_policy = CONSISTENCY_POLICY_BITMAP;
1183 } else if (info->array.level <= 0) {
1184 info->consistency_policy = CONSISTENCY_POLICY_NONE;
1185 } else {
1186 info->consistency_policy = CONSISTENCY_POLICY_RESYNC;
1187 }
1188
1189 info->journal_clean = 0;
1190 }
1191
1192 static struct mdinfo *container_content1(struct supertype *st, char *subarray)
1193 {
1194 struct mdinfo *info;
1195
1196 if (subarray)
1197 return NULL;
1198
1199 info = xmalloc(sizeof(*info));
1200 getinfo_super1(st, info, NULL);
1201 return info;
1202 }
1203
1204 static int update_super1(struct supertype *st, struct mdinfo *info,
1205 char *update, char *devname, int verbose,
1206 int uuid_set, char *homehost)
1207 {
1208 /* NOTE: for 'assemble' and 'force' we need to return non-zero
1209 * if any change was made. For others, the return value is
1210 * ignored.
1211 */
1212 int rv = 0;
1213 struct mdp_superblock_1 *sb = st->sb;
1214 bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb) + MAX_SB_SIZE);
1215
1216 if (strcmp(update, "homehost") == 0 &&
1217 homehost) {
1218 /* Note that 'homehost' is special as it is really
1219 * a "name" update.
1220 */
1221 char *c;
1222 update = "name";
1223 c = strchr(sb->set_name, ':');
1224 if (c)
1225 strncpy(info->name, c+1, 31 - (c-sb->set_name));
1226 else
1227 strncpy(info->name, sb->set_name, 32);
1228 info->name[32] = 0;
1229 }
1230
1231 if (strcmp(update, "force-one")==0) {
1232 /* Not enough devices for a working array,
1233 * so bring this one up-to-date
1234 */
1235 if (sb->events != __cpu_to_le64(info->events))
1236 rv = 1;
1237 sb->events = __cpu_to_le64(info->events);
1238 } else if (strcmp(update, "force-array")==0) {
1239 /* Degraded array and 'force' requests to
1240 * maybe need to mark it 'clean'.
1241 */
1242 switch(__le32_to_cpu(sb->level)) {
1243 case 4:
1244 case 5:
1245 case 6:
1246 /* need to force clean */
1247 if (sb->resync_offset != MaxSector)
1248 rv = 1;
1249 sb->resync_offset = MaxSector;
1250 }
1251 } else if (strcmp(update, "assemble")==0) {
1252 int d = info->disk.number;
1253 int want;
1254 if (info->disk.state & (1<<MD_DISK_ACTIVE))
1255 want = info->disk.raid_disk;
1256 else if (info->disk.state & (1<<MD_DISK_JOURNAL))
1257 want = MD_DISK_ROLE_JOURNAL;
1258 else
1259 want = MD_DISK_ROLE_SPARE;
1260 if (sb->dev_roles[d] != __cpu_to_le16(want)) {
1261 sb->dev_roles[d] = __cpu_to_le16(want);
1262 rv = 1;
1263 }
1264 if (info->reshape_active &&
1265 sb->feature_map &
1266 __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE) &&
1267 info->delta_disks >= 0 &&
1268 info->reshape_progress <
1269 __le64_to_cpu(sb->reshape_position)) {
1270 sb->reshape_position =
1271 __cpu_to_le64(info->reshape_progress);
1272 rv = 1;
1273 }
1274 if (info->reshape_active &&
1275 sb->feature_map &
1276 __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE) &&
1277 info->delta_disks < 0 &&
1278 info->reshape_progress >
1279 __le64_to_cpu(sb->reshape_position)) {
1280 sb->reshape_position =
1281 __cpu_to_le64(info->reshape_progress);
1282 rv = 1;
1283 }
1284 } else if (strcmp(update, "linear-grow-new") == 0) {
1285 int i;
1286 int fd;
1287 int max = __le32_to_cpu(sb->max_dev);
1288
1289 if (max > MAX_DEVS)
1290 return -2;
1291
1292 for (i = 0; i < max; i++)
1293 if (__le16_to_cpu(sb->dev_roles[i]) >=
1294 MD_DISK_ROLE_FAULTY)
1295 break;
1296 if (i != info->disk.number)
1297 return -2;
1298 sb->dev_number = __cpu_to_le32(i);
1299
1300 if (i == max)
1301 sb->max_dev = __cpu_to_le32(max+1);
1302 if (i > max)
1303 return -2;
1304
1305 random_uuid(sb->device_uuid);
1306
1307 sb->dev_roles[i] = __cpu_to_le16(info->disk.raid_disk);
1308
1309 fd = open(devname, O_RDONLY);
1310 if (fd >= 0) {
1311 unsigned long long ds;
1312 get_dev_size(fd, devname, &ds);
1313 close(fd);
1314 ds >>= 9;
1315 if (__le64_to_cpu(sb->super_offset) <
1316 __le64_to_cpu(sb->data_offset)) {
1317 sb->data_size = __cpu_to_le64(
1318 ds - __le64_to_cpu(sb->data_offset));
1319 } else {
1320 ds -= 8*2;
1321 ds &= ~(unsigned long long)(4*2-1);
1322 sb->super_offset = __cpu_to_le64(ds);
1323 sb->data_size = __cpu_to_le64(
1324 ds - __le64_to_cpu(sb->data_offset));
1325 }
1326 }
1327 } else if (strcmp(update, "linear-grow-update") == 0) {
1328 int max = __le32_to_cpu(sb->max_dev);
1329 int i = info->disk.number;
1330 if (max > MAX_DEVS || i > MAX_DEVS)
1331 return -2;
1332 if (i > max)
1333 return -2;
1334 if (i == max)
1335 sb->max_dev = __cpu_to_le32(max+1);
1336 sb->raid_disks = __cpu_to_le32(info->array.raid_disks);
1337 sb->dev_roles[info->disk.number] =
1338 __cpu_to_le16(info->disk.raid_disk);
1339 } else if (strcmp(update, "resync") == 0) {
1340 /* make sure resync happens */
1341 sb->resync_offset = 0ULL;
1342 } else if (strcmp(update, "uuid") == 0) {
1343 copy_uuid(sb->set_uuid, info->uuid, super1.swapuuid);
1344
1345 if (__le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET)
1346 memcpy(bms->uuid, sb->set_uuid, 16);
1347 } else if (strcmp(update, "no-bitmap") == 0) {
1348 sb->feature_map &= ~__cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
1349 } else if (strcmp(update, "bbl") == 0) {
1350 /* only possible if there is room after the bitmap, or if
1351 * there is no bitmap
1352 */
1353 unsigned long long sb_offset = __le64_to_cpu(sb->super_offset);
1354 unsigned long long data_offset = __le64_to_cpu(sb->data_offset);
1355 long bitmap_offset = 0;
1356 long bm_sectors = 0;
1357 long space;
1358
1359 if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BITMAP_OFFSET)) {
1360 bitmap_offset = (long)__le32_to_cpu(sb->bitmap_offset);
1361 bm_sectors = calc_bitmap_size(bms, 4096) >> 9;
1362 } else if (md_feature_any_ppl_on(sb->feature_map)) {
1363 bitmap_offset = (long)__le16_to_cpu(sb->ppl.offset);
1364 bm_sectors = (long)__le16_to_cpu(sb->ppl.size);
1365 }
1366
1367 if (sb_offset < data_offset) {
1368 /*
1369 * 1.1 or 1.2. Put bbl after bitmap leaving
1370 * at least 32K
1371 */
1372 long bb_offset;
1373 bb_offset = sb_offset + 8;
1374 if (bm_sectors && bitmap_offset > 0)
1375 bb_offset = bitmap_offset + bm_sectors;
1376 while (bb_offset < (long)sb_offset + 8 + 32*2 &&
1377 bb_offset + 8+8 <= (long)data_offset)
1378 /* too close to bitmap, and room to grow */
1379 bb_offset += 8;
1380 if (bb_offset + 8 <= (long)data_offset) {
1381 sb->bblog_size = __cpu_to_le16(8);
1382 sb->bblog_offset = __cpu_to_le32(bb_offset);
1383 }
1384 } else {
1385 /* 1.0 - Put bbl just before super block */
1386 if (bm_sectors && bitmap_offset < 0)
1387 space = -bitmap_offset - bm_sectors;
1388 else
1389 space = sb_offset - data_offset -
1390 __le64_to_cpu(sb->data_size);
1391 if (space >= 8) {
1392 sb->bblog_size = __cpu_to_le16(8);
1393 sb->bblog_offset = __cpu_to_le32((unsigned)-8);
1394 }
1395 }
1396 } else if (strcmp(update, "no-bbl") == 0) {
1397 if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BAD_BLOCKS))
1398 pr_err("Cannot remove active bbl from %s\n",devname);
1399 else {
1400 sb->bblog_size = 0;
1401 sb->bblog_shift = 0;
1402 sb->bblog_offset = 0;
1403 }
1404 } else if (strcmp(update, "force-no-bbl") == 0) {
1405 sb->feature_map &= ~ __cpu_to_le32(MD_FEATURE_BAD_BLOCKS);
1406 sb->bblog_size = 0;
1407 sb->bblog_shift = 0;
1408 sb->bblog_offset = 0;
1409 } else if (strcmp(update, "ppl") == 0) {
1410 unsigned long long sb_offset = __le64_to_cpu(sb->super_offset);
1411 unsigned long long data_offset = __le64_to_cpu(sb->data_offset);
1412 unsigned long long data_size = __le64_to_cpu(sb->data_size);
1413 long bb_offset = __le32_to_cpu(sb->bblog_offset);
1414 int space;
1415 int offset;
1416
1417 if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BITMAP_OFFSET)) {
1418 pr_err("Cannot add PPL to array with bitmap\n");
1419 return -2;
1420 }
1421
1422 if (sb->feature_map & __cpu_to_le32(MD_FEATURE_JOURNAL)) {
1423 pr_err("Cannot add PPL to array with journal\n");
1424 return -2;
1425 }
1426
1427 if (sb_offset < data_offset) {
1428 if (bb_offset)
1429 space = bb_offset - 8;
1430 else
1431 space = data_offset - sb_offset - 8;
1432 offset = 8;
1433 } else {
1434 offset = -(sb_offset - data_offset - data_size);
1435 if (offset < INT16_MIN)
1436 offset = INT16_MIN;
1437 space = -(offset - bb_offset);
1438 }
1439
1440 if (space < (PPL_HEADER_SIZE >> 9) + 8) {
1441 pr_err("Not enough space to add ppl\n");
1442 return -2;
1443 }
1444
1445 if (space >= (MULTIPLE_PPL_AREA_SIZE_SUPER1 >> 9)) {
1446 space = (MULTIPLE_PPL_AREA_SIZE_SUPER1 >> 9);
1447 } else {
1448 int optimal_space = choose_ppl_space(
1449 __le32_to_cpu(sb->chunksize));
1450 if (space > optimal_space)
1451 space = optimal_space;
1452 if (space > UINT16_MAX)
1453 space = UINT16_MAX;
1454 }
1455
1456 sb->ppl.offset = __cpu_to_le16(offset);
1457 sb->ppl.size = __cpu_to_le16(space);
1458 sb->feature_map |= __cpu_to_le32(MD_FEATURE_PPL);
1459 } else if (strcmp(update, "no-ppl") == 0) {
1460 sb->feature_map &= ~__cpu_to_le32(MD_FEATURE_PPL |
1461 MD_FEATURE_MUTLIPLE_PPLS);
1462 } else if (strcmp(update, "name") == 0) {
1463 if (info->name[0] == 0)
1464 sprintf(info->name, "%d", info->array.md_minor);
1465 memset(sb->set_name, 0, sizeof(sb->set_name));
1466 if (homehost &&
1467 strchr(info->name, ':') == NULL &&
1468 strlen(homehost)+1+strlen(info->name) < 32) {
1469 strcpy(sb->set_name, homehost);
1470 strcat(sb->set_name, ":");
1471 strcat(sb->set_name, info->name);
1472 } else {
1473 int namelen;
1474
1475 namelen = min((int)strlen(info->name),
1476 (int)sizeof(sb->set_name) - 1);
1477 memcpy(sb->set_name, info->name, namelen);
1478 memset(&sb->set_name[namelen], '\0',
1479 sizeof(sb->set_name) - namelen);
1480 }
1481 } else if (strcmp(update, "devicesize") == 0 &&
1482 __le64_to_cpu(sb->super_offset) <
1483 __le64_to_cpu(sb->data_offset)) {
1484 /* set data_size to device size less data_offset */
1485 struct misc_dev_info *misc = (struct misc_dev_info*)
1486 (st->sb + MAX_SB_SIZE + BM_SUPER_SIZE);
1487 sb->data_size = __cpu_to_le64(
1488 misc->device_size - __le64_to_cpu(sb->data_offset));
1489 } else if (strncmp(update, "revert-reshape", 14) == 0) {
1490 rv = -2;
1491 if (!(sb->feature_map &
1492 __cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE)))
1493 pr_err("No active reshape to revert on %s\n",
1494 devname);
1495 else {
1496 __u32 temp;
1497 unsigned long long reshape_sectors;
1498 long reshape_chunk;
1499 rv = 0;
1500 /* If the reshape hasn't started, just stop it.
1501 * It is conceivable that a stripe was modified but
1502 * the metadata not updated. In that case the backup
1503 * should have been used to get passed the critical stage.
1504 * If that couldn't happen, the "-nobackup" version
1505 * will be used.
1506 */
1507 if (strcmp(update, "revert-reshape-nobackup") == 0 &&
1508 sb->reshape_position == 0 &&
1509 (__le32_to_cpu(sb->delta_disks) > 0 ||
1510 (__le32_to_cpu(sb->delta_disks) == 0 &&
1511 !(sb->feature_map & __cpu_to_le32(MD_FEATURE_RESHAPE_BACKWARDS))))) {
1512 sb->feature_map &= ~__cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE);
1513 sb->raid_disks = __cpu_to_le32(__le32_to_cpu(sb->raid_disks) -
1514 __le32_to_cpu(sb->delta_disks));
1515 sb->delta_disks = 0;
1516 goto done;
1517 }
1518 /* reshape_position is a little messy.
1519 * Its value must be a multiple of the larger
1520 * chunk size, and of the "after" data disks.
1521 * So when reverting we need to change it to
1522 * be a multiple of the new "after" data disks,
1523 * which is the old "before".
1524 * If it isn't already a multiple of 'before',
1525 * the only thing we could do would be
1526 * copy some block around on the disks, which
1527 * is easy to get wrong.
1528 * So we reject a revert-reshape unless the
1529 * alignment is good.
1530 */
1531 if (__le32_to_cpu(sb->level) >= 4 &&
1532 __le32_to_cpu(sb->level) <= 6) {
1533 reshape_sectors =
1534 __le64_to_cpu(sb->reshape_position);
1535 reshape_chunk = __le32_to_cpu(sb->new_chunk);
1536 reshape_chunk *= __le32_to_cpu(sb->raid_disks) -
1537 __le32_to_cpu(sb->delta_disks) -
1538 (__le32_to_cpu(sb->level)==6 ? 2 : 1);
1539 if (reshape_sectors % reshape_chunk) {
1540 pr_err("Reshape position is not suitably aligned.\n");
1541 pr_err("Try normal assembly and stop again\n");
1542 return -2;
1543 }
1544 }
1545 sb->raid_disks =
1546 __cpu_to_le32(__le32_to_cpu(sb->raid_disks) -
1547 __le32_to_cpu(sb->delta_disks));
1548 if (sb->delta_disks == 0)
1549 sb->feature_map ^= __cpu_to_le32(MD_FEATURE_RESHAPE_BACKWARDS);
1550 else
1551 sb->delta_disks = __cpu_to_le32(-__le32_to_cpu(sb->delta_disks));
1552
1553 temp = sb->new_layout;
1554 sb->new_layout = sb->layout;
1555 sb->layout = temp;
1556
1557 temp = sb->new_chunk;
1558 sb->new_chunk = sb->chunksize;
1559 sb->chunksize = temp;
1560
1561 if (sb->feature_map &
1562 __cpu_to_le32(MD_FEATURE_NEW_OFFSET)) {
1563 long offset_delta =
1564 (int32_t)__le32_to_cpu(sb->new_offset);
1565 sb->data_offset = __cpu_to_le64(__le64_to_cpu(sb->data_offset) + offset_delta);
1566 sb->new_offset = __cpu_to_le32(-offset_delta);
1567 sb->data_size = __cpu_to_le64(__le64_to_cpu(sb->data_size) - offset_delta);
1568 }
1569 done:;
1570 }
1571 } else if (strcmp(update, "_reshape_progress") == 0)
1572 sb->reshape_position = __cpu_to_le64(info->reshape_progress);
1573 else if (strcmp(update, "writemostly") == 0)
1574 sb->devflags |= WriteMostly1;
1575 else if (strcmp(update, "readwrite") == 0)
1576 sb->devflags &= ~WriteMostly1;
1577 else if (strcmp(update, "failfast") == 0)
1578 sb->devflags |= FailFast1;
1579 else if (strcmp(update, "nofailfast") == 0)
1580 sb->devflags &= ~FailFast1;
1581 else if (strcmp(update, "layout-original") == 0 ||
1582 strcmp(update, "layout-alternate") == 0 ||
1583 strcmp(update, "layout-unspecified") == 0) {
1584 if (__le32_to_cpu(sb->level) != 0) {
1585 pr_err("%s: %s only supported for RAID0\n",
1586 devname?:"", update);
1587 rv = -1;
1588 } else if (strcmp(update, "layout-unspecified") == 0) {
1589 sb->feature_map &= ~__cpu_to_le32(MD_FEATURE_RAID0_LAYOUT);
1590 sb->layout = 0;
1591 } else {
1592 sb->feature_map |= __cpu_to_le32(MD_FEATURE_RAID0_LAYOUT);
1593 sb->layout = __cpu_to_le32(update[7] == 'o' ? 1 : 2);
1594 }
1595 } else
1596 rv = -1;
1597
1598 sb->sb_csum = calc_sb_1_csum(sb);
1599
1600 return rv;
1601 }
1602
1603 static int init_super1(struct supertype *st, mdu_array_info_t *info,
1604 struct shape *s, char *name, char *homehost,
1605 int *uuid, unsigned long long data_offset)
1606 {
1607 struct mdp_superblock_1 *sb;
1608 int spares;
1609 char defname[10];
1610 int sbsize;
1611
1612 if (posix_memalign((void**)&sb, 4096, SUPER1_SIZE) != 0) {
1613 pr_err("could not allocate superblock\n");
1614 return 0;
1615 }
1616 memset(sb, 0, SUPER1_SIZE);
1617
1618 st->sb = sb;
1619 if (info == NULL) {
1620 /* zeroing superblock */
1621 return 0;
1622 }
1623
1624 spares = info->working_disks - info->active_disks;
1625 if (info->raid_disks + spares > MAX_DEVS) {
1626 pr_err("too many devices requested: %d+%d > %d\n",
1627 info->raid_disks , spares, MAX_DEVS);
1628 return 0;
1629 }
1630
1631 sb->magic = __cpu_to_le32(MD_SB_MAGIC);
1632 sb->major_version = __cpu_to_le32(1);
1633 sb->feature_map = 0;
1634 sb->pad0 = 0;
1635
1636 if (uuid)
1637 copy_uuid(sb->set_uuid, uuid, super1.swapuuid);
1638 else
1639 random_uuid(sb->set_uuid);;
1640
1641 if (name == NULL || *name == 0) {
1642 sprintf(defname, "%d", info->md_minor);
1643 name = defname;
1644 }
1645 if (homehost &&
1646 strchr(name, ':')== NULL &&
1647 strlen(homehost)+1+strlen(name) < 32) {
1648 strcpy(sb->set_name, homehost);
1649 strcat(sb->set_name, ":");
1650 strcat(sb->set_name, name);
1651 } else {
1652 int namelen;
1653
1654 namelen = min((int)strlen(name),
1655 (int)sizeof(sb->set_name) - 1);
1656 memcpy(sb->set_name, name, namelen);
1657 memset(&sb->set_name[namelen], '\0',
1658 sizeof(sb->set_name) - namelen);
1659 }
1660
1661 sb->ctime = __cpu_to_le64((unsigned long long)time(0));
1662 sb->level = __cpu_to_le32(info->level);
1663 sb->layout = __cpu_to_le32(info->layout);
1664 sb->size = __cpu_to_le64(s->size*2ULL);
1665 sb->chunksize = __cpu_to_le32(info->chunk_size>>9);
1666 sb->raid_disks = __cpu_to_le32(info->raid_disks);
1667
1668 sb->data_offset = __cpu_to_le64(data_offset);
1669 sb->data_size = __cpu_to_le64(0);
1670 sb->super_offset = __cpu_to_le64(0);
1671 sb->recovery_offset = __cpu_to_le64(0);
1672
1673 sb->utime = sb->ctime;
1674 sb->events = __cpu_to_le64(1);
1675 if (info->state & (1<<MD_SB_CLEAN))
1676 sb->resync_offset = MaxSector;
1677 else
1678 sb->resync_offset = 0;
1679 sbsize = sizeof(struct mdp_superblock_1) +
1680 2 * (info->raid_disks + spares);
1681 sbsize = ROUND_UP(sbsize, 512);
1682 sb->max_dev =
1683 __cpu_to_le32((sbsize - sizeof(struct mdp_superblock_1)) / 2);
1684
1685 memset(sb->dev_roles, 0xff,
1686 MAX_SB_SIZE - sizeof(struct mdp_superblock_1));
1687
1688 if (s->consistency_policy == CONSISTENCY_POLICY_PPL)
1689 sb->feature_map |= __cpu_to_le32(MD_FEATURE_PPL);
1690
1691 return 1;
1692 }
1693
1694 struct devinfo {
1695 int fd;
1696 char *devname;
1697 long long data_offset;
1698 unsigned long long dev_size;
1699 mdu_disk_info_t disk;
1700 struct devinfo *next;
1701 };
1702
1703 /* Add a device to the superblock being created */
1704 static int add_to_super1(struct supertype *st, mdu_disk_info_t *dk,
1705 int fd, char *devname, unsigned long long data_offset)
1706 {
1707 struct mdp_superblock_1 *sb = st->sb;
1708 __u16 *rp = sb->dev_roles + dk->number;
1709 struct devinfo *di, **dip;
1710 int dk_state;
1711
1712 dk_state = dk->state & ~(1<<MD_DISK_FAILFAST);
1713 if ((dk_state & (1<<MD_DISK_ACTIVE)) &&
1714 (dk_state & (1<<MD_DISK_SYNC)))/* active, sync */
1715 *rp = __cpu_to_le16(dk->raid_disk);
1716 else if (dk_state & (1<<MD_DISK_JOURNAL))
1717 *rp = MD_DISK_ROLE_JOURNAL;
1718 else if ((dk_state & ~(1<<MD_DISK_ACTIVE)) == 0)
1719 /* active or idle -> spare */
1720 *rp = MD_DISK_ROLE_SPARE;
1721 else
1722 *rp = MD_DISK_ROLE_FAULTY;
1723
1724 if (dk->number >= (int)__le32_to_cpu(sb->max_dev) &&
1725 __le32_to_cpu(sb->max_dev) < MAX_DEVS)
1726 sb->max_dev = __cpu_to_le32(dk->number+1);
1727
1728 sb->dev_number = __cpu_to_le32(dk->number);
1729 sb->devflags = 0; /* don't copy another disks flags */
1730 sb->sb_csum = calc_sb_1_csum(sb);
1731
1732 dip = (struct devinfo **)&st->info;
1733 while (*dip)
1734 dip = &(*dip)->next;
1735 di = xmalloc(sizeof(struct devinfo));
1736 di->fd = fd;
1737 di->devname = devname;
1738 di->disk = *dk;
1739 di->data_offset = data_offset;
1740 get_dev_size(fd, NULL, &di->dev_size);
1741 di->next = NULL;
1742 *dip = di;
1743
1744 return 0;
1745 }
1746
1747 static int locate_bitmap1(struct supertype *st, int fd, int node_num);
1748
1749 static int store_super1(struct supertype *st, int fd)
1750 {
1751 struct mdp_superblock_1 *sb = st->sb;
1752 unsigned long long sb_offset;
1753 struct align_fd afd;
1754 int sbsize;
1755 unsigned long long dsize;
1756
1757 if (!get_dev_size(fd, NULL, &dsize))
1758 return 1;
1759
1760 dsize >>= 9;
1761
1762 if (dsize < 24)
1763 return 2;
1764
1765 init_afd(&afd, fd);
1766
1767 /*
1768 * Calculate the position of the superblock.
1769 * It is always aligned to a 4K boundary and
1770 * depending on minor_version, it can be:
1771 * 0: At least 8K, but less than 12K, from end of device
1772 * 1: At start of device
1773 * 2: 4K from start of device.
1774 */
1775 switch(st->minor_version) {
1776 case 0:
1777 sb_offset = dsize;
1778 sb_offset -= 8*2;
1779 sb_offset &= ~(4*2-1);
1780 break;
1781 case 1:
1782 sb_offset = 0;
1783 break;
1784 case 2:
1785 sb_offset = 4*2;
1786 break;
1787 default:
1788 return -EINVAL;
1789 }
1790
1791 if (sb_offset != __le64_to_cpu(sb->super_offset) &&
1792 0 != __le64_to_cpu(sb->super_offset)
1793 ) {
1794 pr_err("internal error - sb_offset is wrong\n");
1795 abort();
1796 }
1797
1798 if (lseek64(fd, sb_offset << 9, 0)< 0LL)
1799 return 3;
1800
1801 sbsize = ROUND_UP(sizeof(*sb) + 2 * __le32_to_cpu(sb->max_dev), 512);
1802
1803 if (awrite(&afd, sb, sbsize) != sbsize)
1804 return 4;
1805
1806 if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BITMAP_OFFSET)) {
1807 struct bitmap_super_s *bm = (struct bitmap_super_s*)
1808 (((char*)sb)+MAX_SB_SIZE);
1809 if (__le32_to_cpu(bm->magic) == BITMAP_MAGIC) {
1810 locate_bitmap1(st, fd, 0);
1811 if (awrite(&afd, bm, sizeof(*bm)) != sizeof(*bm))
1812 return 5;
1813 }
1814 }
1815 fsync(fd);
1816
1817 return 0;
1818 }
1819
1820 static int load_super1(struct supertype *st, int fd, char *devname);
1821
1822 static unsigned long choose_bm_space(unsigned long devsize)
1823 {
1824 /* if the device is bigger than 8Gig, save 64k for bitmap usage,
1825 * if bigger than 200Gig, save 128k
1826 * NOTE: result must be multiple of 4K else bad things happen
1827 * on 4K-sector devices.
1828 */
1829 if (devsize < 64*2)
1830 return 0;
1831 if (devsize - 64*2 >= 200*1024*1024*2)
1832 return 128*2;
1833 if (devsize - 4*2 > 8*1024*1024*2)
1834 return 64*2;
1835 return 4*2;
1836 }
1837
1838 static void free_super1(struct supertype *st);
1839
1840 __u32 crc32c_le(__u32 crc, unsigned char const *p, size_t len);
1841
1842 static int write_init_ppl1(struct supertype *st, struct mdinfo *info, int fd)
1843 {
1844 struct mdp_superblock_1 *sb = st->sb;
1845 void *buf;
1846 struct ppl_header *ppl_hdr;
1847 int ret;
1848
1849 /* first clear entire ppl space */
1850 ret = zero_disk_range(fd, info->ppl_sector, info->ppl_size);
1851 if (ret)
1852 return ret;
1853
1854 ret = posix_memalign(&buf, 4096, PPL_HEADER_SIZE);
1855 if (ret) {
1856 pr_err("Failed to allocate PPL header buffer\n");
1857 return ret;
1858 }
1859
1860 memset(buf, 0, PPL_HEADER_SIZE);
1861 ppl_hdr = buf;
1862 memset(ppl_hdr->reserved, 0xff, PPL_HDR_RESERVED);
1863 ppl_hdr->signature = __cpu_to_le32(~crc32c_le(~0, sb->set_uuid,
1864 sizeof(sb->set_uuid)));
1865 ppl_hdr->checksum = __cpu_to_le32(~crc32c_le(~0, buf, PPL_HEADER_SIZE));
1866
1867 if (lseek64(fd, info->ppl_sector * 512, SEEK_SET) < 0) {
1868 ret = errno;
1869 perror("Failed to seek to PPL header location");
1870 }
1871
1872 if (!ret && write(fd, buf, PPL_HEADER_SIZE) != PPL_HEADER_SIZE) {
1873 ret = errno;
1874 perror("Write PPL header failed");
1875 }
1876
1877 if (!ret)
1878 fsync(fd);
1879
1880 free(buf);
1881 return ret;
1882 }
1883
1884 #define META_BLOCK_SIZE 4096
1885
1886 static int write_empty_r5l_meta_block(struct supertype *st, int fd)
1887 {
1888 struct r5l_meta_block *mb;
1889 struct mdp_superblock_1 *sb = st->sb;
1890 struct align_fd afd;
1891 __u32 crc;
1892
1893 init_afd(&afd, fd);
1894
1895 if (posix_memalign((void**)&mb, 4096, META_BLOCK_SIZE) != 0) {
1896 pr_err("Could not allocate memory for the meta block.\n");
1897 return 1;
1898 }
1899
1900 memset(mb, 0, META_BLOCK_SIZE);
1901
1902 mb->magic = __cpu_to_le32(R5LOG_MAGIC);
1903 mb->version = R5LOG_VERSION;
1904 mb->meta_size = __cpu_to_le32(sizeof(struct r5l_meta_block));
1905 mb->seq = __cpu_to_le64(random32());
1906 mb->position = __cpu_to_le64(0);
1907
1908 crc = crc32c_le(0xffffffff, sb->set_uuid, sizeof(sb->set_uuid));
1909 crc = crc32c_le(crc, (void *)mb, META_BLOCK_SIZE);
1910 mb->checksum = crc;
1911
1912 if (lseek64(fd, __le64_to_cpu(sb->data_offset) * 512, 0) < 0LL) {
1913 pr_err("cannot seek to offset of the meta block\n");
1914 goto fail_to_write;
1915 }
1916
1917 if (awrite(&afd, mb, META_BLOCK_SIZE) != META_BLOCK_SIZE) {
1918 pr_err("failed to store write the meta block \n");
1919 goto fail_to_write;
1920 }
1921 fsync(fd);
1922
1923 free(mb);
1924 return 0;
1925
1926 fail_to_write:
1927 free(mb);
1928 return 1;
1929 }
1930
1931 static int write_init_super1(struct supertype *st)
1932 {
1933 struct mdp_superblock_1 *sb = st->sb;
1934 struct supertype *refst;
1935 int rv = 0;
1936 unsigned long long bm_space;
1937 struct devinfo *di;
1938 unsigned long long dsize, array_size;
1939 unsigned long long sb_offset;
1940 unsigned long long data_offset;
1941 long bm_offset;
1942 int raid0_need_layout = 0;
1943
1944 for (di = st->info; di; di = di->next) {
1945 if (di->disk.state & (1 << MD_DISK_JOURNAL))
1946 sb->feature_map |= __cpu_to_le32(MD_FEATURE_JOURNAL);
1947 if (sb->level == 0 && sb->layout != 0) {
1948 struct devinfo *di2 = st->info;
1949 unsigned long long s1, s2;
1950 s1 = di->dev_size;
1951 if (di->data_offset != INVALID_SECTORS)
1952 s1 -= di->data_offset;
1953 s1 /= __le32_to_cpu(sb->chunksize);
1954 s2 = di2->dev_size;
1955 if (di2->data_offset != INVALID_SECTORS)
1956 s2 -= di2->data_offset;
1957 s2 /= __le32_to_cpu(sb->chunksize);
1958 if (s1 != s2)
1959 raid0_need_layout = 1;
1960 }
1961 }
1962
1963 for (di = st->info; di; di = di->next) {
1964 if (di->disk.state & (1 << MD_DISK_FAULTY))
1965 continue;
1966 if (di->fd < 0)
1967 continue;
1968
1969 while (Kill(di->devname, NULL, 0, -1, 1) == 0)
1970 ;
1971
1972 sb->dev_number = __cpu_to_le32(di->disk.number);
1973 if (di->disk.state & (1<<MD_DISK_WRITEMOSTLY))
1974 sb->devflags |= WriteMostly1;
1975 else
1976 sb->devflags &= ~WriteMostly1;
1977 if (di->disk.state & (1<<MD_DISK_FAILFAST))
1978 sb->devflags |= FailFast1;
1979 else
1980 sb->devflags &= ~FailFast1;
1981
1982 random_uuid(sb->device_uuid);
1983
1984 if (!(di->disk.state & (1<<MD_DISK_JOURNAL)))
1985 sb->events = 0;
1986
1987 refst = dup_super(st);
1988 if (load_super1(refst, di->fd, NULL)==0) {
1989 struct mdp_superblock_1 *refsb = refst->sb;
1990
1991 memcpy(sb->device_uuid, refsb->device_uuid, 16);
1992 if (memcmp(sb->set_uuid, refsb->set_uuid, 16)==0) {
1993 /* same array, so preserve events and
1994 * dev_number */
1995 sb->events = refsb->events;
1996 /* bugs in 2.6.17 and earlier mean the
1997 * dev_number chosen in Manage must be preserved
1998 */
1999 if (get_linux_version() >= 2006018)
2000 sb->dev_number = refsb->dev_number;
2001 }
2002 free_super1(refst);
2003 }
2004 free(refst);
2005
2006 if (!get_dev_size(di->fd, NULL, &dsize)) {
2007 rv = 1;
2008 goto error_out;
2009 }
2010 dsize >>= 9;
2011
2012 if (dsize < 24) {
2013 close(di->fd);
2014 rv = 2;
2015 goto error_out;
2016 }
2017
2018 /*
2019 * Calculate the position of the superblock.
2020 * It is always aligned to a 4K boundary and
2021 * depending on minor_version, it can be:
2022 * 0: At least 8K, but less than 12K, from end of device
2023 * 1: At start of device
2024 * 2: 4K from start of device.
2025 * data_offset has already been set.
2026 */
2027 array_size = __le64_to_cpu(sb->size);
2028
2029 /* work out how much space we left for a bitmap */
2030 if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BITMAP_OFFSET)) {
2031 bitmap_super_t *bms = (bitmap_super_t *)
2032 (((char *)sb) + MAX_SB_SIZE);
2033 bm_space = calc_bitmap_size(bms, 4096) >> 9;
2034 bm_offset = (long)__le32_to_cpu(sb->bitmap_offset);
2035 } else if (md_feature_any_ppl_on(sb->feature_map)) {
2036 bm_space = MULTIPLE_PPL_AREA_SIZE_SUPER1 >> 9;
2037 if (st->minor_version == 0)
2038 bm_offset = -bm_space - 8;
2039 else
2040 bm_offset = 8;
2041 sb->ppl.offset = __cpu_to_le16(bm_offset);
2042 sb->ppl.size = __cpu_to_le16(bm_space);
2043 } else {
2044 bm_space = choose_bm_space(array_size);
2045 bm_offset = 8;
2046 }
2047
2048 data_offset = di->data_offset;
2049 if (data_offset == INVALID_SECTORS)
2050 data_offset = st->data_offset;
2051 switch(st->minor_version) {
2052 case 0:
2053 /* Add 8 sectors for bad block log */
2054 bm_space += 8;
2055 if (data_offset == INVALID_SECTORS)
2056 data_offset = 0;
2057 sb_offset = dsize;
2058 sb_offset -= 8*2;
2059 sb_offset &= ~(4*2-1);
2060 sb->data_offset = __cpu_to_le64(data_offset);
2061 sb->super_offset = __cpu_to_le64(sb_offset);
2062 if (sb_offset < array_size + bm_space)
2063 bm_space = sb_offset - array_size;
2064 sb->data_size = __cpu_to_le64(sb_offset - bm_space);
2065 if (bm_space >= 8) {
2066 sb->bblog_size = __cpu_to_le16(8);
2067 sb->bblog_offset = __cpu_to_le32((unsigned)-8);
2068 }
2069 break;
2070 case 1:
2071 case 2:
2072 sb_offset = st->minor_version == 2 ? 8 : 0;
2073 sb->super_offset = __cpu_to_le64(sb_offset);
2074 if (data_offset == INVALID_SECTORS)
2075 data_offset = sb_offset + 16;
2076
2077 sb->data_offset = __cpu_to_le64(data_offset);
2078 sb->data_size = __cpu_to_le64(dsize - data_offset);
2079 if (data_offset >= sb_offset+bm_offset+bm_space+8) {
2080 sb->bblog_size = __cpu_to_le16(8);
2081 sb->bblog_offset = __cpu_to_le32(bm_offset +
2082 bm_space);
2083 } else if (data_offset >= sb_offset + 16) {
2084 sb->bblog_size = __cpu_to_le16(8);
2085 /* '8' sectors for the bblog, and 'sb_offset'
2086 * because we want offset from superblock, not
2087 * start of device.
2088 */
2089 sb->bblog_offset = __cpu_to_le32(data_offset -
2090 8 - sb_offset);
2091 }
2092 break;
2093 default:
2094 pr_err("Failed to write invalid metadata format 1.%i to %s\n",
2095 st->minor_version, di->devname);
2096 rv = -EINVAL;
2097 goto out;
2098 }
2099 /*
2100 * Disable badblock log on clusters, or when
2101 * explicitly requested
2102 */
2103 if (st->nodes > 0 || conf_get_create_info()->bblist == 0) {
2104 sb->bblog_size = 0;
2105 sb->bblog_offset = 0;
2106 }
2107
2108 /* RAID0 needs a layout if devices aren't all the same size */
2109 if (raid0_need_layout)
2110 sb->feature_map |= __cpu_to_le32(MD_FEATURE_RAID0_LAYOUT);
2111
2112 sb->sb_csum = calc_sb_1_csum(sb);
2113 rv = store_super1(st, di->fd);
2114
2115 if (rv == 0 && (di->disk.state & (1 << MD_DISK_JOURNAL))) {
2116 rv = write_empty_r5l_meta_block(st, di->fd);
2117 if (rv)
2118 goto error_out;
2119 }
2120
2121 if (rv == 0 &&
2122 (__le32_to_cpu(sb->feature_map) &
2123 MD_FEATURE_BITMAP_OFFSET)) {
2124 rv = st->ss->write_bitmap(st, di->fd, NodeNumUpdate);
2125 } else if (rv == 0 &&
2126 md_feature_any_ppl_on(sb->feature_map)) {
2127 struct mdinfo info;
2128
2129 st->ss->getinfo_super(st, &info, NULL);
2130 rv = st->ss->write_init_ppl(st, &info, di->fd);
2131 }
2132
2133 close(di->fd);
2134 di->fd = -1;
2135 if (rv)
2136 goto error_out;
2137 }
2138 error_out:
2139 if (rv)
2140 pr_err("Failed to write metadata to %s\n", di->devname);
2141 out:
2142 return rv;
2143 }
2144
2145 static int compare_super1(struct supertype *st, struct supertype *tst)
2146 {
2147 /*
2148 * return:
2149 * 0 same, or first was empty, and second was copied
2150 * 1 second had wrong number
2151 * 2 wrong uuid
2152 * 3 wrong other info
2153 */
2154 struct mdp_superblock_1 *first = st->sb;
2155 struct mdp_superblock_1 *second = tst->sb;
2156
2157 if (second->magic != __cpu_to_le32(MD_SB_MAGIC))
2158 return 1;
2159 if (second->major_version != __cpu_to_le32(1))
2160 return 1;
2161
2162 if (!first) {
2163 if (posix_memalign((void**)&first, 4096, SUPER1_SIZE) != 0) {
2164 pr_err("could not allocate superblock\n");
2165 return 1;
2166 }
2167 memcpy(first, second, SUPER1_SIZE);
2168 st->sb = first;
2169 return 0;
2170 }
2171 if (memcmp(first->set_uuid, second->set_uuid, 16)!= 0)
2172 return 2;
2173
2174 if (first->ctime != second->ctime ||
2175 first->level != second->level ||
2176 first->layout != second->layout ||
2177 first->size != second->size ||
2178 first->chunksize != second->chunksize ||
2179 first->raid_disks != second->raid_disks)
2180 return 3;
2181 return 0;
2182 }
2183
2184 static int load_super1(struct supertype *st, int fd, char *devname)
2185 {
2186 unsigned long long dsize;
2187 unsigned long long sb_offset;
2188 struct mdp_superblock_1 *super;
2189 int uuid[4];
2190 struct bitmap_super_s *bsb;
2191 struct misc_dev_info *misc;
2192 struct align_fd afd;
2193
2194 free_super1(st);
2195
2196 init_afd(&afd, fd);
2197
2198 if (st->ss == NULL || st->minor_version == -1) {
2199 int bestvers = -1;
2200 struct supertype tst;
2201 __u64 bestctime = 0;
2202 /* guess... choose latest ctime */
2203 memset(&tst, 0, sizeof(tst));
2204 tst.ss = &super1;
2205 for (tst.minor_version = 0; tst.minor_version <= 2;
2206 tst.minor_version++) {
2207 switch(load_super1(&tst, fd, devname)) {
2208 case 0: super = tst.sb;
2209 if (bestvers == -1 ||
2210 bestctime < __le64_to_cpu(super->ctime)) {
2211 bestvers = tst.minor_version;
2212 bestctime = __le64_to_cpu(super->ctime);
2213 }
2214 free(super);
2215 tst.sb = NULL;
2216 break;
2217 case 1: return 1; /*bad device */
2218 case 2: break; /* bad, try next */
2219 }
2220 }
2221 if (bestvers != -1) {
2222 int rv;
2223 tst.minor_version = bestvers;
2224 tst.ss = &super1;
2225 tst.max_devs = MAX_DEVS;
2226 rv = load_super1(&tst, fd, devname);
2227 if (rv == 0)
2228 *st = tst;
2229 return rv;
2230 }
2231 return 2;
2232 }
2233 if (!get_dev_size(fd, devname, &dsize))
2234 return 1;
2235 dsize >>= 9;
2236
2237 if (dsize < 24) {
2238 if (devname)
2239 pr_err("%s is too small for md: size is %llu sectors.\n",
2240 devname, dsize);
2241 return 1;
2242 }
2243
2244 /*
2245 * Calculate the position of the superblock.
2246 * It is always aligned to a 4K boundary and
2247 * depending on minor_version, it can be:
2248 * 0: At least 8K, but less than 12K, from end of device
2249 * 1: At start of device
2250 * 2: 4K from start of device.
2251 */
2252 switch(st->minor_version) {
2253 case 0:
2254 sb_offset = dsize;
2255 sb_offset -= 8*2;
2256 sb_offset &= ~(4*2-1);
2257 break;
2258 case 1:
2259 sb_offset = 0;
2260 break;
2261 case 2:
2262 sb_offset = 4*2;
2263 break;
2264 default:
2265 return -EINVAL;
2266 }
2267
2268 if (lseek64(fd, sb_offset << 9, 0)< 0LL) {
2269 if (devname)
2270 pr_err("Cannot seek to superblock on %s: %s\n",
2271 devname, strerror(errno));
2272 return 1;
2273 }
2274
2275 if (posix_memalign((void**)&super, 4096, SUPER1_SIZE) != 0) {
2276 pr_err("could not allocate superblock\n");
2277 return 1;
2278 }
2279
2280 memset(super, 0, SUPER1_SIZE);
2281
2282 if (aread(&afd, super, MAX_SB_SIZE) != MAX_SB_SIZE) {
2283 if (devname)
2284 pr_err("Cannot read superblock on %s\n",
2285 devname);
2286 free(super);
2287 return 1;
2288 }
2289
2290 if (__le32_to_cpu(super->magic) != MD_SB_MAGIC) {
2291 if (devname)
2292 pr_err("No super block found on %s (Expected magic %08x, got %08x)\n",
2293 devname, MD_SB_MAGIC,
2294 __le32_to_cpu(super->magic));
2295 free(super);
2296 return 2;
2297 }
2298
2299 if (__le32_to_cpu(super->major_version) != 1) {
2300 if (devname)
2301 pr_err("Cannot interpret superblock on %s - version is %d\n",
2302 devname, __le32_to_cpu(super->major_version));
2303 free(super);
2304 return 2;
2305 }
2306 if (__le64_to_cpu(super->super_offset) != sb_offset) {
2307 if (devname)
2308 pr_err("No superblock found on %s (super_offset is wrong)\n",
2309 devname);
2310 free(super);
2311 return 2;
2312 }
2313 st->sb = super;
2314
2315 bsb = (struct bitmap_super_s *)(((char*)super)+MAX_SB_SIZE);
2316
2317 misc = (struct misc_dev_info*)
2318 (((char*)super)+MAX_SB_SIZE+BM_SUPER_SIZE);
2319 misc->device_size = dsize;
2320 if (st->data_offset == INVALID_SECTORS)
2321 st->data_offset = __le64_to_cpu(super->data_offset);
2322
2323 /* Now check on the bitmap superblock */
2324 if ((__le32_to_cpu(super->feature_map)&MD_FEATURE_BITMAP_OFFSET) == 0)
2325 return 0;
2326 /* Read the bitmap superblock and make sure it looks
2327 * valid. If it doesn't clear the bit. An --assemble --force
2328 * should get that written out.
2329 */
2330 locate_bitmap1(st, fd, 0);
2331 if (aread(&afd, bsb, 512) != 512)
2332 goto no_bitmap;
2333
2334 uuid_from_super1(st, uuid);
2335 if (__le32_to_cpu(bsb->magic) != BITMAP_MAGIC ||
2336 memcmp(bsb->uuid, uuid, 16) != 0)
2337 goto no_bitmap;
2338 return 0;
2339
2340 no_bitmap:
2341 super->feature_map = __cpu_to_le32(__le32_to_cpu(super->feature_map)
2342 & ~MD_FEATURE_BITMAP_OFFSET);
2343 return 0;
2344 }
2345
2346 static struct supertype *match_metadata_desc1(char *arg)
2347 {
2348 struct supertype *st = xcalloc(1, sizeof(*st));
2349
2350 st->container_devnm[0] = 0;
2351 st->ss = &super1;
2352 st->max_devs = MAX_DEVS;
2353 st->sb = NULL;
2354 st->data_offset = INVALID_SECTORS;
2355 /* leading zeros can be safely ignored. --detail generates them. */
2356 while (*arg == '0')
2357 arg++;
2358 if (strcmp(arg, "1.0") == 0 || strcmp(arg, "1.00") == 0) {
2359 st->minor_version = 0;
2360 return st;
2361 }
2362 if (strcmp(arg, "1.1") == 0 || strcmp(arg, "1.01") == 0
2363 ) {
2364 st->minor_version = 1;
2365 return st;
2366 }
2367 if (strcmp(arg, "1.2") == 0 ||
2368 #ifndef DEFAULT_OLD_METADATA /* ifdef in super0.c */
2369 strcmp(arg, "default") == 0 ||
2370 #endif /* DEFAULT_OLD_METADATA */
2371 strcmp(arg, "1.02") == 0) {
2372 st->minor_version = 2;
2373 return st;
2374 }
2375 if (strcmp(arg, "1") == 0 || strcmp(arg, "default") == 0) {
2376 st->minor_version = -1;
2377 return st;
2378 }
2379
2380 free(st);
2381 return NULL;
2382 }
2383
2384 /* find available size on device with this devsize, using
2385 * superblock type st, and reserving 'reserve' sectors for
2386 * a possible bitmap
2387 */
2388 static __u64 avail_size1(struct supertype *st, __u64 devsize,
2389 unsigned long long data_offset)
2390 {
2391 struct mdp_superblock_1 *super = st->sb;
2392 int bmspace = 0;
2393 int bbspace = 0;
2394 if (devsize < 24)
2395 return 0;
2396
2397 if (__le32_to_cpu(super->feature_map) & MD_FEATURE_BITMAP_OFFSET) {
2398 /* hot-add. allow for actual size of bitmap */
2399 struct bitmap_super_s *bsb;
2400 bsb = (struct bitmap_super_s *)(((char*)super)+MAX_SB_SIZE);
2401 bmspace = calc_bitmap_size(bsb, 4096) >> 9;
2402 } else if (md_feature_any_ppl_on(super->feature_map)) {
2403 bmspace = __le16_to_cpu(super->ppl.size);
2404 }
2405
2406 /* Allow space for bad block log */
2407 if (super->bblog_size)
2408 bbspace = __le16_to_cpu(super->bblog_size);
2409
2410 if (st->minor_version < 0)
2411 /* not specified, so time to set default */
2412 st->minor_version = 2;
2413
2414 if (data_offset == INVALID_SECTORS)
2415 data_offset = st->data_offset;
2416
2417 if (data_offset != INVALID_SECTORS)
2418 switch(st->minor_version) {
2419 case 0:
2420 return devsize - data_offset - 8*2 - bbspace;
2421 case 1:
2422 case 2:
2423 return devsize - data_offset;
2424 default:
2425 return 0;
2426 }
2427
2428 devsize -= bmspace;
2429
2430 switch(st->minor_version) {
2431 case 0:
2432 /* at end */
2433 return ((devsize - 8*2 - bbspace ) & ~(4*2-1));
2434 case 1:
2435 /* at start, 4K for superblock and possible bitmap */
2436 return devsize - 4*2 - bbspace;
2437 case 2:
2438 /* 4k from start, 4K for superblock and possible bitmap */
2439 return devsize - (4+4)*2 - bbspace;
2440 }
2441 return 0;
2442 }
2443
2444 static int
2445 add_internal_bitmap1(struct supertype *st,
2446 int *chunkp, int delay, int write_behind,
2447 unsigned long long size,
2448 int may_change, int major)
2449 {
2450 /*
2451 * If not may_change, then this is a 'Grow' without sysfs support for
2452 * bitmaps, and the bitmap must fit after the superblock at 1K offset.
2453 * If may_change, then this is create or a Grow with sysfs support,
2454 * and we can put the bitmap wherever we like.
2455 *
2456 * size is in sectors, chunk is in bytes !!!
2457 */
2458
2459 unsigned long long bits;
2460 unsigned long long max_bits;
2461 unsigned long long min_chunk;
2462 long offset;
2463 long bbl_offset, bbl_size;
2464 unsigned long long chunk = *chunkp;
2465 int room = 0;
2466 int creating = 0;
2467 int len;
2468 struct mdp_superblock_1 *sb = st->sb;
2469 bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb) + MAX_SB_SIZE);
2470 int uuid[4];
2471
2472 if (__le64_to_cpu(sb->data_size) == 0)
2473 /*
2474 * Must be creating the array, else data_size
2475 * would be non-zero
2476 */
2477 creating = 1;
2478 switch(st->minor_version) {
2479 case 0:
2480 /*
2481 * either 3K after the superblock (when hot-add),
2482 * or some amount of space before.
2483 */
2484 if (creating) {
2485 /*
2486 * We are creating array, so we *know* how much room has
2487 * been left.
2488 */
2489 offset = 0;
2490 bbl_size = 8;
2491 room =
2492 choose_bm_space(__le64_to_cpu(sb->size)) + bbl_size;
2493 } else {
2494 room = __le64_to_cpu(sb->super_offset)
2495 - __le64_to_cpu(sb->data_offset)
2496 - __le64_to_cpu(sb->data_size);
2497 bbl_size = __le16_to_cpu(sb->bblog_size);
2498 if (bbl_size < 8)
2499 bbl_size = 8;
2500 bbl_offset = (__s32)__le32_to_cpu(sb->bblog_offset);
2501 if (bbl_size < -bbl_offset)
2502 bbl_size = -bbl_offset;
2503
2504 if (!may_change ||
2505 (room < 3*2 && __le32_to_cpu(sb->max_dev) <= 384)) {
2506 room = 3*2;
2507 offset = 1*2;
2508 bbl_size = 0;
2509 } else {
2510 offset = 0; /* means movable offset */
2511 }
2512 }
2513 break;
2514 case 1:
2515 case 2: /* between superblock and data */
2516 if (creating) {
2517 offset = 4*2;
2518 bbl_size = 8;
2519 room =
2520 choose_bm_space(__le64_to_cpu(sb->size)) + bbl_size;
2521 } else {
2522 room = __le64_to_cpu(sb->data_offset)
2523 - __le64_to_cpu(sb->super_offset);
2524 bbl_size = __le16_to_cpu(sb->bblog_size);
2525 if (bbl_size)
2526 room =
2527 __le32_to_cpu(sb->bblog_offset) + bbl_size;
2528 else
2529 bbl_size = 8;
2530
2531 if (!may_change) {
2532 room -= 2; /* Leave 1K for superblock */
2533 offset = 2;
2534 bbl_size = 0;
2535 } else {
2536 room -= 4*2; /* leave 4K for superblock */
2537 offset = 4*2;
2538 }
2539 }
2540 break;
2541 default:
2542 return -ENOSPC;
2543 }
2544
2545 room -= bbl_size;
2546 if (chunk == UnSet && room > 128*2)
2547 /* Limit to 128K of bitmap when chunk size not requested */
2548 room = 128*2;
2549
2550 if (room <= 1)
2551 /* No room for a bitmap */
2552 return -ENOSPC;
2553
2554 max_bits = (room * 512 - sizeof(bitmap_super_t)) * 8;
2555
2556 min_chunk = 4096; /* sub-page chunks don't work yet.. */
2557 bits = (size*512)/min_chunk +1;
2558 while (bits > max_bits) {
2559 min_chunk *= 2;
2560 bits = (bits+1)/2;
2561 }
2562 if (chunk == UnSet) {
2563 /* For practical purpose, 64Meg is a good
2564 * default chunk size for internal bitmaps.
2565 */
2566 chunk = min_chunk;
2567 if (chunk < 64*1024*1024)
2568 chunk = 64*1024*1024;
2569 } else if (chunk < min_chunk)
2570 return -EINVAL; /* chunk size too small */
2571 if (chunk == 0) /* rounding problem */
2572 return -EINVAL;
2573
2574 if (offset == 0) {
2575 /* start bitmap on a 4K boundary with enough space for
2576 * the bitmap
2577 */
2578 bits = (size*512) / chunk + 1;
2579 room = ((bits+7)/8 + sizeof(bitmap_super_t) +4095)/4096;
2580 room *= 8; /* convert 4K blocks to sectors */
2581 offset = -room - bbl_size;
2582 }
2583
2584 sb->bitmap_offset = (int32_t)__cpu_to_le32(offset);
2585
2586 sb->feature_map = __cpu_to_le32(__le32_to_cpu(sb->feature_map) |
2587 MD_FEATURE_BITMAP_OFFSET);
2588 memset(bms, 0, sizeof(*bms));
2589 bms->magic = __cpu_to_le32(BITMAP_MAGIC);
2590 bms->version = __cpu_to_le32(major);
2591 uuid_from_super1(st, uuid);
2592 memcpy(bms->uuid, uuid, 16);
2593 bms->chunksize = __cpu_to_le32(chunk);
2594 bms->daemon_sleep = __cpu_to_le32(delay);
2595 bms->sync_size = __cpu_to_le64(size);
2596 bms->write_behind = __cpu_to_le32(write_behind);
2597 bms->nodes = __cpu_to_le32(st->nodes);
2598 if (st->nodes)
2599 sb->feature_map = __cpu_to_le32(__le32_to_cpu(sb->feature_map) |
2600 MD_FEATURE_BITMAP_VERSIONED);
2601 if (st->cluster_name) {
2602 len = sizeof(bms->cluster_name);
2603 strncpy((char *)bms->cluster_name, st->cluster_name, len);
2604 bms->cluster_name[len - 1] = '\0';
2605 }
2606
2607 *chunkp = chunk;
2608 return 0;
2609 }
2610
2611 static int locate_bitmap1(struct supertype *st, int fd, int node_num)
2612 {
2613 unsigned long long offset, bm_sectors_per_node;
2614 struct mdp_superblock_1 *sb;
2615 bitmap_super_t *bms;
2616 int mustfree = 0;
2617 int ret;
2618
2619 if (!st->sb) {
2620 if (st->ss->load_super(st, fd, NULL))
2621 return -1; /* no error I hope... */
2622 mustfree = 1;
2623 }
2624 sb = st->sb;
2625
2626 if ((__le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET))
2627 ret = 0;
2628 else
2629 ret = -1;
2630
2631 offset = __le64_to_cpu(sb->super_offset) + __le32_to_cpu(sb->bitmap_offset);
2632 if (node_num) {
2633 bms = (bitmap_super_t*)(((char*)sb)+MAX_SB_SIZE);
2634 bm_sectors_per_node = calc_bitmap_size(bms, 4096) >> 9;
2635 offset += bm_sectors_per_node * node_num;
2636 }
2637 if (mustfree)
2638 free(sb);
2639 lseek64(fd, offset<<9, 0);
2640 return ret;
2641 }
2642
2643 static int write_bitmap1(struct supertype *st, int fd, enum bitmap_update update)
2644 {
2645 struct mdp_superblock_1 *sb = st->sb;
2646 bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb)+MAX_SB_SIZE);
2647 int rv = 0;
2648 void *buf;
2649 int towrite, n, len;
2650 struct align_fd afd;
2651 unsigned int i = 0;
2652 unsigned long long total_bm_space, bm_space_per_node;
2653
2654 switch (update) {
2655 case NameUpdate:
2656 /* update cluster name */
2657 if (st->cluster_name) {
2658 len = sizeof(bms->cluster_name);
2659 memset((char *)bms->cluster_name, 0, len);
2660 strncpy((char *)bms->cluster_name,
2661 st->cluster_name, len);
2662 bms->cluster_name[len - 1] = '\0';
2663 }
2664 break;
2665 case NodeNumUpdate:
2666 /* cluster md only supports superblock 1.2 now */
2667 if (st->minor_version != 2 &&
2668 bms->version == BITMAP_MAJOR_CLUSTERED) {
2669 pr_err("Warning: cluster md only works with superblock 1.2\n");
2670 return -EINVAL;
2671 }
2672
2673 if (bms->version == BITMAP_MAJOR_CLUSTERED) {
2674 if (__cpu_to_le32(st->nodes) < bms->nodes) {
2675 /*
2676 * Since the nodes num is not increased, no
2677 * need to check the space enough or not,
2678 * just update bms->nodes
2679 */
2680 bms->nodes = __cpu_to_le32(st->nodes);
2681 break;
2682 }
2683 } else {
2684 /*
2685 * no need to change bms->nodes for other
2686 * bitmap types
2687 */
2688 if (st->nodes)
2689 pr_err("Warning: --nodes option is only suitable for clustered bitmap\n");
2690 break;
2691 }
2692
2693 /*
2694 * Each node has an independent bitmap, it is necessary to
2695 * calculate the space is enough or not, first get how many
2696 * bytes for the total bitmap
2697 */
2698 bm_space_per_node = calc_bitmap_size(bms, 4096);
2699
2700 total_bm_space = 512 * (__le64_to_cpu(sb->data_offset) -
2701 __le64_to_cpu(sb->super_offset));
2702 /* leave another 4k for superblock */
2703 total_bm_space = total_bm_space - 4096;
2704
2705 if (bm_space_per_node * st->nodes > total_bm_space) {
2706 pr_err("Warning: The max num of nodes can't exceed %llu\n",
2707 total_bm_space / bm_space_per_node);
2708 return -ENOMEM;
2709 }
2710
2711 bms->nodes = __cpu_to_le32(st->nodes);
2712 break;
2713 case NoUpdate:
2714 default:
2715 break;
2716 }
2717
2718 init_afd(&afd, fd);
2719
2720 locate_bitmap1(st, fd, 0);
2721
2722 if (posix_memalign(&buf, 4096, 4096))
2723 return -ENOMEM;
2724
2725 do {
2726 /* Only the bitmap[0] should resync
2727 * whole device on initial assembly
2728 */
2729 if (i)
2730 memset(buf, 0x00, 4096);
2731 else
2732 memset(buf, 0xff, 4096);
2733 memcpy(buf, (char *)bms, sizeof(bitmap_super_t));
2734
2735 /*
2736 * use 4096 boundary if bitmap_offset is aligned
2737 * with 8 sectors, then it should compatible with
2738 * older mdadm.
2739 */
2740 if (__le32_to_cpu(sb->bitmap_offset) & 7)
2741 towrite = calc_bitmap_size(bms, 512);
2742 else
2743 towrite = calc_bitmap_size(bms, 4096);
2744 while (towrite > 0) {
2745 n = towrite;
2746 if (n > 4096)
2747 n = 4096;
2748 n = awrite(&afd, buf, n);
2749 if (n > 0)
2750 towrite -= n;
2751 else
2752 break;
2753 if (i)
2754 memset(buf, 0x00, 4096);
2755 else
2756 memset(buf, 0xff, 4096);
2757 }
2758 fsync(fd);
2759 if (towrite) {
2760 rv = -2;
2761 break;
2762 }
2763 } while (++i < __le32_to_cpu(bms->nodes));
2764
2765 free(buf);
2766 return rv;
2767 }
2768
2769 static void free_super1(struct supertype *st)
2770 {
2771
2772 if (st->sb)
2773 free(st->sb);
2774 while (st->info) {
2775 struct devinfo *di = st->info;
2776 st->info = di->next;
2777 if (di->fd >= 0)
2778 close(di->fd);
2779 free(di);
2780 }
2781 st->sb = NULL;
2782 }
2783
2784 static int validate_geometry1(struct supertype *st, int level,
2785 int layout, int raiddisks,
2786 int *chunk, unsigned long long size,
2787 unsigned long long data_offset,
2788 char *subdev, unsigned long long *freesize,
2789 int consistency_policy, int verbose)
2790 {
2791 unsigned long long ldsize, devsize;
2792 int bmspace;
2793 unsigned long long headroom;
2794 unsigned long long overhead;
2795 int fd;
2796
2797 if (level == LEVEL_CONTAINER) {
2798 if (verbose)
2799 pr_err("1.x metadata does not support containers\n");
2800 return 0;
2801 }
2802 if (*chunk == UnSet)
2803 *chunk = DEFAULT_CHUNK;
2804
2805 if (!subdev)
2806 return 1;
2807
2808 if (st->minor_version < 0)
2809 /* not specified, so time to set default */
2810 st->minor_version = 2;
2811
2812 fd = open(subdev, O_RDONLY|O_EXCL, 0);
2813 if (fd < 0) {
2814 if (verbose)
2815 pr_err("super1.x cannot open %s: %s\n",
2816 subdev, strerror(errno));
2817 return 0;
2818 }
2819
2820 if (!get_dev_size(fd, subdev, &ldsize)) {
2821 close(fd);
2822 return 0;
2823 }
2824 close(fd);
2825
2826 devsize = ldsize >> 9;
2827
2828 /* creating: allow suitable space for bitmap or PPL */
2829 if (consistency_policy == CONSISTENCY_POLICY_PPL)
2830 bmspace = MULTIPLE_PPL_AREA_SIZE_SUPER1 >> 9;
2831 else
2832 bmspace = choose_bm_space(devsize);
2833
2834 if (data_offset == INVALID_SECTORS)
2835 data_offset = st->data_offset;
2836 if (data_offset == INVALID_SECTORS)
2837 switch (st->minor_version) {
2838 case 0:
2839 data_offset = 0;
2840 break;
2841 case 1:
2842 case 2:
2843 /* Choose data offset appropriate for this device
2844 * and use as default for whole array.
2845 * The data_offset must allow for bitmap space
2846 * and base metadata, should allow for some headroom
2847 * for reshape, and should be rounded to multiple
2848 * of 1M.
2849 * Headroom is limited to 128M, but aim for about 0.1%
2850 */
2851 headroom = 128*1024*2;
2852 while ((headroom << 10) > devsize &&
2853 (*chunk == 0 ||
2854 headroom / 2 >= ((unsigned)(*chunk)*2)*2))
2855 headroom >>= 1;
2856 data_offset = 12*2 + bmspace + headroom;
2857 #define ONE_MEG (2*1024)
2858 data_offset = ROUND_UP(data_offset, ONE_MEG);
2859 break;
2860 }
2861 if (st->data_offset == INVALID_SECTORS)
2862 st->data_offset = data_offset;
2863 switch(st->minor_version) {
2864 case 0: /* metadata at end. Round down and subtract space to reserve */
2865 devsize = (devsize & ~(4ULL*2-1));
2866 /* space for metadata, bblog, bitmap/ppl */
2867 overhead = 8*2 + 8 + bmspace;
2868 if (devsize < overhead) /* detect underflow */
2869 goto dev_too_small_err;
2870 devsize -= overhead;
2871 break;
2872 case 1:
2873 case 2:
2874 if (devsize < data_offset) /* detect underflow */
2875 goto dev_too_small_err;
2876 devsize -= data_offset;
2877 break;
2878 }
2879 *freesize = devsize;
2880 return 1;
2881
2882 /* Error condition, device cannot even hold the overhead. */
2883 dev_too_small_err:
2884 fprintf(stderr, "device %s is too small (%lluK) for "
2885 "required metadata!\n", subdev, devsize>>1);
2886 *freesize = 0;
2887 return 0;
2888 }
2889
2890 void *super1_make_v0(struct supertype *st, struct mdinfo *info, mdp_super_t *sb0)
2891 {
2892 /* Create a v1.0 superblock based on 'info'*/
2893 void *ret;
2894 struct mdp_superblock_1 *sb;
2895 int i;
2896 unsigned long long offset;
2897
2898 if (posix_memalign(&ret, 4096, 1024) != 0)
2899 return NULL;
2900 sb = ret;
2901 memset(ret, 0, 1024);
2902 sb->magic = __cpu_to_le32(MD_SB_MAGIC);
2903 sb->major_version = __cpu_to_le32(1);
2904
2905 copy_uuid(sb->set_uuid, info->uuid, super1.swapuuid);
2906 sprintf(sb->set_name, "%d", sb0->md_minor);
2907 sb->ctime = __cpu_to_le32(info->array.ctime+1);
2908 sb->level = __cpu_to_le32(info->array.level);
2909 sb->layout = __cpu_to_le32(info->array.layout);
2910 sb->size = __cpu_to_le64(info->component_size);
2911 sb->chunksize = __cpu_to_le32(info->array.chunk_size/512);
2912 sb->raid_disks = __cpu_to_le32(info->array.raid_disks);
2913 if (info->array.level > 0)
2914 sb->data_size = sb->size;
2915 else
2916 sb->data_size = st->ss->avail_size(st, st->devsize/512, 0);
2917 sb->resync_offset = MaxSector;
2918 sb->max_dev = __cpu_to_le32(MD_SB_DISKS);
2919 sb->dev_number = __cpu_to_le32(info->disk.number);
2920 sb->utime = __cpu_to_le64(info->array.utime);
2921
2922 offset = st->devsize/512 - 8*2;
2923 offset &= ~(4*2-1);
2924 sb->super_offset = __cpu_to_le64(offset);
2925 //*(__u64*)(st->other + 128 + 8 + 8) = __cpu_to_le64(offset);
2926
2927 random_uuid(sb->device_uuid);
2928
2929 for (i = 0; i < MD_SB_DISKS; i++) {
2930 int state = sb0->disks[i].state;
2931 sb->dev_roles[i] = MD_DISK_ROLE_SPARE;
2932 if ((state & (1<<MD_DISK_SYNC)) &&
2933 !(state & (1<<MD_DISK_FAULTY)))
2934 sb->dev_roles[i] = __cpu_to_le16(sb0->disks[i].raid_disk);
2935 }
2936 sb->sb_csum = calc_sb_1_csum(sb);
2937 return ret;
2938 }
2939
2940 struct superswitch super1 = {
2941 .examine_super = examine_super1,
2942 .brief_examine_super = brief_examine_super1,
2943 .export_examine_super = export_examine_super1,
2944 .detail_super = detail_super1,
2945 .brief_detail_super = brief_detail_super1,
2946 .export_detail_super = export_detail_super1,
2947 .write_init_super = write_init_super1,
2948 .validate_geometry = validate_geometry1,
2949 .add_to_super = add_to_super1,
2950 .examine_badblocks = examine_badblocks_super1,
2951 .copy_metadata = copy_metadata1,
2952 .write_init_ppl = write_init_ppl1,
2953 .match_home = match_home1,
2954 .uuid_from_super = uuid_from_super1,
2955 .getinfo_super = getinfo_super1,
2956 .container_content = container_content1,
2957 .update_super = update_super1,
2958 .init_super = init_super1,
2959 .store_super = store_super1,
2960 .compare_super = compare_super1,
2961 .load_super = load_super1,
2962 .match_metadata_desc = match_metadata_desc1,
2963 .avail_size = avail_size1,
2964 .add_internal_bitmap = add_internal_bitmap1,
2965 .locate_bitmap = locate_bitmap1,
2966 .write_bitmap = write_bitmap1,
2967 .free_super = free_super1,
2968 #if __BYTE_ORDER == BIG_ENDIAN
2969 .swapuuid = 0,
2970 #else
2971 .swapuuid = 1,
2972 #endif
2973 .name = "1.x",
2974 };
Unnamed repository; edit this file 'description' to name the repository.