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