Replace sysarray with mdinfo
[thirdparty/mdadm.git] / Grow.c
CommitLineData
e5329c37
NB
1/*
2 * mdadm - manage Linux "md" devices aka RAID arrays.
3 *
4f589ad0 4 * Copyright (C) 2001-2006 Neil Brown <neilb@suse.de>
e5329c37
NB
5 *
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 * Author: Neil Brown
22 * Email: <neilb@cse.unsw.edu.au>
23 * Paper: Neil Brown
24 * School of Computer Science and Engineering
25 * The University of New South Wales
26 * Sydney, 2052
27 * Australia
28 */
29#include "mdadm.h"
30#include "dlink.h"
31
32#if ! defined(__BIG_ENDIAN) && ! defined(__LITTLE_ENDIAN)
33#error no endian defined
34#endif
35#include "md_u.h"
36#include "md_p.h"
37
38int Grow_Add_device(char *devname, int fd, char *newdev)
39{
40 /* Add a device to an active array.
41 * Currently, just extend a linear array.
42 * This requires writing a new superblock on the
43 * new device, calling the kernel to add the device,
44 * and if that succeeds, update the superblock on
45 * all other devices.
46 * This means that we need to *find* all other devices.
47 */
4b1ac34b
NB
48 struct mdinfo info;
49
e5329c37
NB
50 struct stat stb;
51 int nfd, fd2;
52 int d, nd;
82d9eba6 53 struct supertype *st = NULL;
aba69144 54
e5329c37 55
4b1ac34b 56 if (ioctl(fd, GET_ARRAY_INFO, &info.array) < 0) {
e5329c37
NB
57 fprintf(stderr, Name ": cannot get array info for %s\n", devname);
58 return 1;
59 }
60
1686dc25 61 st = super_by_fd(fd);
82d9eba6 62 if (!st) {
f9ce90ba
NB
63 fprintf(stderr, Name ": cannot handle arrays with superblock version %d\n", info.array.major_version);
64 return 1;
65 }
66
4b1ac34b 67 if (info.array.level != -1) {
e5329c37
NB
68 fprintf(stderr, Name ": can only add devices to linear arrays\n");
69 return 1;
70 }
71
72 nfd = open(newdev, O_RDWR|O_EXCL);
73 if (nfd < 0) {
74 fprintf(stderr, Name ": cannot open %s\n", newdev);
75 return 1;
76 }
77 fstat(nfd, &stb);
78 if ((stb.st_mode & S_IFMT) != S_IFBLK) {
79 fprintf(stderr, Name ": %s is not a block device!\n", newdev);
80 close(nfd);
81 return 1;
82 }
83 /* now check out all the devices and make sure we can read the superblock */
4b1ac34b 84 for (d=0 ; d < info.array.raid_disks ; d++) {
e5329c37
NB
85 mdu_disk_info_t disk;
86 char *dv;
87
88 disk.number = d;
89 if (ioctl(fd, GET_DISK_INFO, &disk) < 0) {
90 fprintf(stderr, Name ": cannot get device detail for device %d\n",
91 d);
92 return 1;
93 }
16c6fa80 94 dv = map_dev(disk.major, disk.minor, 1);
e5329c37
NB
95 if (!dv) {
96 fprintf(stderr, Name ": cannot find device file for device %d\n",
97 d);
98 return 1;
99 }
16c6fa80 100 fd2 = dev_open(dv, O_RDWR);
e5329c37
NB
101 if (!fd2) {
102 fprintf(stderr, Name ": cannot open device file %s\n", dv);
103 return 1;
104 }
3da92f27
NB
105 st->ss->free_super(st);
106
107 if (st->ss->load_super(st, fd2, NULL)) {
e5329c37
NB
108 fprintf(stderr, Name ": cannot find super block on %s\n", dv);
109 close(fd2);
110 return 1;
111 }
112 close(fd2);
113 }
114 /* Ok, looks good. Lets update the superblock and write it out to
115 * newdev.
116 */
aba69144 117
4b1ac34b
NB
118 info.disk.number = d;
119 info.disk.major = major(stb.st_rdev);
120 info.disk.minor = minor(stb.st_rdev);
121 info.disk.raid_disk = d;
122 info.disk.state = (1 << MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE);
3da92f27 123 st->ss->update_super(st, &info, "linear-grow-new", newdev,
f752781f 124 0, 0, NULL);
e5329c37 125
3da92f27 126 if (st->ss->store_super(st, nfd)) {
f752781f
NB
127 fprintf(stderr, Name ": Cannot store new superblock on %s\n",
128 newdev);
e5329c37
NB
129 close(nfd);
130 return 1;
131 }
e5329c37 132 close(nfd);
4b1ac34b
NB
133
134 if (ioctl(fd, ADD_NEW_DISK, &info.disk) != 0) {
e5329c37
NB
135 fprintf(stderr, Name ": Cannot add new disk to this array\n");
136 return 1;
137 }
138 /* Well, that seems to have worked.
139 * Now go through and update all superblocks
140 */
141
4b1ac34b 142 if (ioctl(fd, GET_ARRAY_INFO, &info.array) < 0) {
e5329c37
NB
143 fprintf(stderr, Name ": cannot get array info for %s\n", devname);
144 return 1;
145 }
146
147 nd = d;
4b1ac34b 148 for (d=0 ; d < info.array.raid_disks ; d++) {
e5329c37
NB
149 mdu_disk_info_t disk;
150 char *dv;
151
152 disk.number = d;
153 if (ioctl(fd, GET_DISK_INFO, &disk) < 0) {
154 fprintf(stderr, Name ": cannot get device detail for device %d\n",
155 d);
156 return 1;
157 }
16c6fa80 158 dv = map_dev(disk.major, disk.minor, 1);
e5329c37
NB
159 if (!dv) {
160 fprintf(stderr, Name ": cannot find device file for device %d\n",
161 d);
162 return 1;
163 }
16c6fa80 164 fd2 = dev_open(dv, O_RDWR);
e5329c37
NB
165 if (fd2 < 0) {
166 fprintf(stderr, Name ": cannot open device file %s\n", dv);
167 return 1;
168 }
3da92f27 169 if (st->ss->load_super(st, fd2, NULL)) {
e5329c37
NB
170 fprintf(stderr, Name ": cannot find super block on %s\n", dv);
171 close(fd);
172 return 1;
173 }
4b1ac34b
NB
174 info.array.raid_disks = nd+1;
175 info.array.nr_disks = nd+1;
176 info.array.active_disks = nd+1;
177 info.array.working_disks = nd+1;
f752781f 178
3da92f27 179 st->ss->update_super(st, &info, "linear-grow-update", dv,
f752781f 180 0, 0, NULL);
aba69144 181
3da92f27 182 if (st->ss->store_super(st, fd2)) {
e5329c37
NB
183 fprintf(stderr, Name ": Cannot store new superblock on %s\n", dv);
184 close(fd2);
185 return 1;
186 }
187 close(fd2);
188 }
189
190 return 0;
191}
f5e166fe 192
8fac0577 193int Grow_addbitmap(char *devname, int fd, char *file, int chunk, int delay, int write_behind, int force)
f5e166fe
NB
194{
195 /*
196 * First check that array doesn't have a bitmap
197 * Then create the bitmap
198 * Then add it
199 *
200 * For internal bitmaps, we need to check the version,
201 * find all the active devices, and write the bitmap block
202 * to all devices
203 */
204 mdu_bitmap_file_t bmf;
205 mdu_array_info_t array;
206 struct supertype *st;
dcec9ee5
NB
207 int major = BITMAP_MAJOR_HI;
208 int vers = md_get_version(fd);
8fac0577 209 unsigned long long bitmapsize, array_size;
dcec9ee5
NB
210
211 if (vers < 9003) {
212 major = BITMAP_MAJOR_HOSTENDIAN;
213#ifdef __BIG_ENDIAN
214 fprintf(stderr, Name ": Warning - bitmaps created on this kernel are not portable\n"
215 " between different architectured. Consider upgrading the Linux kernel.\n");
216#endif
217 }
f5e166fe
NB
218
219 if (ioctl(fd, GET_BITMAP_FILE, &bmf) != 0) {
353632d9 220 if (errno == ENOMEM)
f5e166fe
NB
221 fprintf(stderr, Name ": Memory allocation failure.\n");
222 else
223 fprintf(stderr, Name ": bitmaps not supported by this kernel.\n");
224 return 1;
225 }
226 if (bmf.pathname[0]) {
fe80f49b
NB
227 if (strcmp(file,"none")==0) {
228 if (ioctl(fd, SET_BITMAP_FILE, -1)!= 0) {
229 fprintf(stderr, Name ": failed to remove bitmap %s\n",
230 bmf.pathname);
231 return 1;
232 }
233 return 0;
234 }
f5e166fe
NB
235 fprintf(stderr, Name ": %s already has a bitmap (%s)\n",
236 devname, bmf.pathname);
237 return 1;
238 }
239 if (ioctl(fd, GET_ARRAY_INFO, &array) != 0) {
240 fprintf(stderr, Name ": cannot get array status for %s\n", devname);
241 return 1;
242 }
243 if (array.state & (1<<MD_SB_BITMAP_PRESENT)) {
fe80f49b
NB
244 if (strcmp(file, "none")==0) {
245 array.state &= ~(1<<MD_SB_BITMAP_PRESENT);
246 if (ioctl(fd, SET_ARRAY_INFO, &array)!= 0) {
247 fprintf(stderr, Name ": failed to remove internal bitmap.\n");
248 return 1;
249 }
250 return 0;
251 }
f5e166fe
NB
252 fprintf(stderr, Name ": Internal bitmap already present on %s\n",
253 devname);
254 return 1;
255 }
5b28bd56
NB
256 if (array.level <= 0) {
257 fprintf(stderr, Name ": Bitmaps not meaningful with level %s\n",
258 map_num(pers, array.level)?:"of this array");
259 return 1;
260 }
8fac0577
NB
261 bitmapsize = array.size;
262 bitmapsize <<= 1;
beae1dfe 263 if (get_dev_size(fd, NULL, &array_size) &&
8fac0577
NB
264 array_size > (0x7fffffffULL<<9)) {
265 /* Array is big enough that we cannot trust array.size
266 * try other approaches
267 */
268 bitmapsize = get_component_size(fd);
269 }
8fac0577
NB
270 if (bitmapsize == 0) {
271 fprintf(stderr, Name ": Cannot reliably determine size of array to create bitmap - sorry.\n");
272 return 1;
273 }
274
f9c25f1d 275 if (array.level == 10) {
8686f3ed 276 int ncopies = (array.layout&255)*((array.layout>>8)&255);
f9c25f1d
NB
277 bitmapsize = bitmapsize * array.raid_disks / ncopies;
278 }
279
1686dc25 280 st = super_by_fd(fd);
f5e166fe
NB
281 if (!st) {
282 fprintf(stderr, Name ": Cannot understand version %d.%d\n",
283 array.major_version, array.minor_version);
284 return 1;
285 }
fe80f49b
NB
286 if (strcmp(file, "none") == 0) {
287 fprintf(stderr, Name ": no bitmap found on %s\n", devname);
288 return 1;
289 } else if (strcmp(file, "internal") == 0) {
f5e166fe 290 int d;
ea329559 291 for (d=0; d< st->max_devs; d++) {
f5e166fe
NB
292 mdu_disk_info_t disk;
293 char *dv;
294 disk.number = d;
295 if (ioctl(fd, GET_DISK_INFO, &disk) < 0)
296 continue;
297 if (disk.major == 0 &&
298 disk.minor == 0)
299 continue;
300 if ((disk.state & (1<<MD_DISK_SYNC))==0)
301 continue;
16c6fa80 302 dv = map_dev(disk.major, disk.minor, 1);
f5e166fe 303 if (dv) {
16c6fa80 304 int fd2 = dev_open(dv, O_RDWR);
f5e166fe
NB
305 if (fd2 < 0)
306 continue;
3da92f27 307 if (st->ss->load_super(st, fd2, NULL)==0) {
199171a2 308 if (st->ss->add_internal_bitmap(
3da92f27 309 st,
199171a2
NB
310 &chunk, delay, write_behind,
311 bitmapsize, 0, major)
312 )
3da92f27 313 st->ss->write_bitmap(st, fd2);
21e92547
NB
314 else {
315 fprintf(stderr, Name ": failed to create internal bitmap - chunksize problem.\n");
316 close(fd2);
317 return 1;
318 }
f5e166fe
NB
319 }
320 close(fd2);
321 }
322 }
323 array.state |= (1<<MD_SB_BITMAP_PRESENT);
324 if (ioctl(fd, SET_ARRAY_INFO, &array)!= 0) {
325 fprintf(stderr, Name ": failed to set internal bitmap.\n");
326 return 1;
327 }
fe80f49b
NB
328 } else {
329 int uuid[4];
330 int bitmap_fd;
331 int d;
332 int max_devs = st->max_devs;
fe80f49b
NB
333
334 /* try to load a superblock */
335 for (d=0; d<max_devs; d++) {
336 mdu_disk_info_t disk;
337 char *dv;
338 int fd2;
339 disk.number = d;
340 if (ioctl(fd, GET_DISK_INFO, &disk) < 0)
341 continue;
342 if ((disk.major==0 && disk.minor==0) ||
343 (disk.state & (1<<MD_DISK_REMOVED)))
344 continue;
16c6fa80 345 dv = map_dev(disk.major, disk.minor, 1);
fe80f49b 346 if (!dv) continue;
16c6fa80 347 fd2 = dev_open(dv, O_RDONLY);
fe80f49b 348 if (fd2 >= 0 &&
3da92f27 349 st->ss->load_super(st, fd2, NULL) == 0) {
fe80f49b 350 close(fd2);
3da92f27 351 st->ss->uuid_from_super(st, uuid);
fe80f49b
NB
352 break;
353 }
354 close(fd2);
355 }
356 if (d == max_devs) {
357 fprintf(stderr, Name ": cannot find UUID for array!\n");
358 return 1;
359 }
8fac0577 360 if (CreateBitmap(file, force, (char*)uuid, chunk,
f9c25f1d 361 delay, write_behind, bitmapsize, major)) {
fe80f49b
NB
362 return 1;
363 }
364 bitmap_fd = open(file, O_RDWR);
365 if (bitmap_fd < 0) {
8fac0577 366 fprintf(stderr, Name ": weird: %s cannot be opened\n",
fe80f49b
NB
367 file);
368 return 1;
369 }
370 if (ioctl(fd, SET_BITMAP_FILE, bitmap_fd) < 0) {
371 fprintf(stderr, Name ": Cannot set bitmap file for %s: %s\n",
372 devname, strerror(errno));
373 return 1;
374 }
375 }
f5e166fe
NB
376
377 return 0;
378}
379
e86c9dd6
NB
380
381/*
382 * When reshaping an array we might need to backup some data.
383 * This is written to all spares with a 'super_block' describing it.
384 * The superblock goes 1K form the end of the used space on the
385 * device.
386 * It if written after the backup is complete.
387 * It has the following structure.
388 */
389
390struct mdp_backup_super {
391 char magic[16]; /* md_backup_data-1 */
392 __u8 set_uuid[16];
393 __u64 mtime;
394 /* start/sizes in 512byte sectors */
395 __u64 devstart;
396 __u64 arraystart;
397 __u64 length;
398 __u32 sb_csum; /* csum of preceeding bytes. */
399};
400
401int bsb_csum(char *buf, int len)
402{
403 int i;
404 int csum = 0;
405 for (i=0; i<len; i++)
406 csum = (csum<<3) + buf[0];
407 return __cpu_to_le32(csum);
408}
409
06b0d786 410int Grow_reshape(char *devname, int fd, int quiet, char *backup_file,
e86c9dd6
NB
411 long long size,
412 int level, int layout, int chunksize, int raid_disks)
413{
414 /* Make some changes in the shape of an array.
415 * The kernel must support the change.
416 * Different reshapes have subtly different meaning for different
417 * levels, so we need to check the current state of the array
418 * and go from there.
419 */
420 struct mdu_array_info_s array;
421 char *c;
422
423 struct mdp_backup_super bsb;
424 struct supertype *st;
425
426 int nlevel, olevel;
427 int nchunk, ochunk;
428 int nlayout, olayout;
429 int ndisks, odisks;
430 int ndata, odata;
431 unsigned long long nstripe, ostripe, last_block;
432 int *fdlist;
433 unsigned long long *offsets;
434 int d, i, spares;
435 int nrdisks;
436 int err;
e86c9dd6 437
7e0f6979 438 struct mdinfo *sra;
06c7f68e 439 struct mdinfo *sd;
e86c9dd6
NB
440
441 if (ioctl(fd, GET_ARRAY_INFO, &array) < 0) {
442 fprintf(stderr, Name ": %s is not an active md array - aborting\n",
443 devname);
444 return 1;
445 }
446 c = map_num(pers, array.level);
447 if (c == NULL) c = "-unknown-";
448 switch(array.level) {
449 default: /* raid0, linear, multipath cannot be reconfigured */
450 fprintf(stderr, Name ": %s array %s cannot be reshaped.\n",
451 c, devname);
452 return 1;
453
454 case LEVEL_FAULTY: /* only 'layout' change is permitted */
455
456 if (size >= 0) {
457 fprintf(stderr, Name ": %s: Cannot change size of a 'faulty' array\n",
458 devname);
459 return 1;
460 }
461 if (level != UnSet && level != LEVEL_FAULTY) {
462 fprintf(stderr, Name ": %s: Cannot change RAID level of a 'faulty' array\n",
463 devname);
464 return 1;
465 }
466 if (chunksize || raid_disks) {
467 fprintf(stderr, Name ": %s: Cannot change chunksize or disks of a 'faulty' array\n",
468 devname);
469 return 1;
470 }
471 if (layout == UnSet)
472 return 0; /* nothing to do.... */
473
474 array.layout = layout;
475 if (ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
476 fprintf(stderr, Name ": Cannot set layout for %s: %s\n",
477 devname, strerror(errno));
478 return 1;
479 }
480 if (!quiet)
481 printf("layout for %s set to %d\n", devname, array.layout);
482 return 0;
483
484 case 1: /* raid_disks and size can each be changed. They are independant */
485
486 if (level != UnSet && level != 1) {
487 fprintf(stderr, Name ": %s: Cannot change RAID level of a RAID1 array.\n",
488 devname);
489 return 1;
490 }
491 if (chunksize || layout != UnSet) {
492 fprintf(stderr, Name ": %s: Cannot change chunk size of layout for a RAID1 array.\n",
493 devname);
494 return 1;
495 }
496
497 /* Each can trigger a resync/recovery which will block the
498 * other from happening. Later we could block
499 * resync for the duration via 'sync_action'...
500 */
9860f271 501 if (raid_disks > 0) {
e86c9dd6 502 array.raid_disks = raid_disks;
9860f271
NB
503 if (ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
504 fprintf(stderr, Name ": Cannot set raid-devices for %s: %s\n",
505 devname, strerror(errno));
506 return 1;
507 }
508 }
509 if (size >= 0) {
e86c9dd6 510 array.size = size;
9860f271
NB
511 if (ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
512 fprintf(stderr, Name ": Cannot set device size for %s: %s\n",
513 devname, strerror(errno));
514 return 1;
515 }
e86c9dd6
NB
516 }
517 return 0;
518
519 case 4:
520 case 5:
521 case 6:
1686dc25
NB
522 st = super_by_fd(fd);
523
758d3a8e 524 /* size can be changed independently.
e86c9dd6
NB
525 * layout/chunksize/raid_disks/level can be changed
526 * though the kernel may not support it all.
527 * If 'suspend_lo' is not present in devfs, then
528 * these cannot be changed.
529 */
530 if (size >= 0) {
531 /* Cannot change other details as well.. */
532 if (layout != UnSet ||
533 chunksize != 0 ||
534 raid_disks != 0 ||
535 level != UnSet) {
536 fprintf(stderr, Name ": %s: Cannot change shape as well as size of a %s array.\n",
537 devname, c);
538 return 1;
539 }
540 array.size = size;
541 if (ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
542 fprintf(stderr, Name ": Cannot set device size/shape for %s: %s\n",
543 devname, strerror(errno));
544 return 1;
545 }
546 return 0;
547 }
548 /* Ok, just change the shape. This can be awkward.
549 * There are three possibilities.
550 * 1/ The array will shrink. We don't support this
551 * possibility. Maybe one day...
552 * 2/ The array will not change size. This is easy enough
553 * to do, but not reliably. If the process is aborted
554 * the array *will* be corrupted. So maybe we can allow
555 * this but only if the user is really certain. e.g.
556 * --really-risk-everything
557 * 3/ The array will grow. This can be reliably achieved.
558 * However the kernel's restripe routines will cheerfully
559 * overwrite some early data before it is safe. So we
560 * need to make a backup of the early parts of the array
561 * and be ready to restore it if rebuild aborts very early.
562 *
563 * We backup data by writing it to all spares (there must be
564 * at least 1, so even raid6->raid5 requires a spare to be
565 * present).
566 *
567 * So: we enumerate the devices in the array and
568 * make sure we can open all of them.
569 * Then we freeze the early part of the array and
570 * backup to the various spares.
571 * Then we request changes and start the reshape.
572 * Monitor progress until it has passed the danger zone.
573 * and finally invalidate the copied data and unfreeze the
574 * start of the array.
575 *
576 * Before we can do this we need to decide:
577 * - will the array grow? Just calculate size
578 * - how much needs to be saved: count stripes.
579 * - where to save data... good question.
580 *
581 */
582 nlevel = olevel = array.level;
583 nchunk = ochunk = array.chunk_size;
584 nlayout = olayout = array.layout;
585 ndisks = odisks = array.raid_disks;
586
587 if (level != UnSet) nlevel = level;
588 if (chunksize) nchunk = chunksize;
589 if (layout != UnSet) nlayout = layout;
590 if (raid_disks) ndisks = raid_disks;
591
592 odata = odisks-1;
593 if (olevel == 6) odata--; /* number of data disks */
594 ndata = ndisks-1;
595 if (nlevel == 6) ndata--;
596
597 if (ndata < odata) {
598 fprintf(stderr, Name ": %s: Cannot reduce number of data disks (yet).\n",
599 devname);
600 return 1;
601 }
602 if (ndata == odata) {
603 fprintf(stderr, Name ": %s: Cannot reshape array without increasing size (yet).\n",
604 devname);
605 return 1;
606 }
607 /* Well, it is growing... so how much do we need to backup.
608 * Need to backup a full number of new-stripes, such that the
609 * last one does not over-write any place that it would be read
610 * from
611 */
612 nstripe = ostripe = 0;
353632d9 613 while (nstripe >= ostripe) {
e86c9dd6
NB
614 nstripe += nchunk/512;
615 last_block = nstripe * ndata;
353632d9 616 ostripe = last_block / odata / (ochunk/512) * (ochunk/512);
e86c9dd6 617 }
353632d9 618 printf("mdadm: Need to backup %lluK of critical section..\n", last_block/2);
e86c9dd6
NB
619
620 sra = sysfs_read(fd, 0,
758d3a8e
NB
621 GET_COMPONENT|GET_DEVS|GET_OFFSET|GET_STATE|
622 GET_CACHE);
e86c9dd6
NB
623 if (!sra) {
624 fprintf(stderr, Name ": %s: Cannot get array details from sysfs\n",
625 devname);
626 return 1;
627 }
628
629 if (last_block >= sra->component_size/2) {
630 fprintf(stderr, Name ": %s: Something wrong - reshape aborted\n",
631 devname);
632 return 1;
633 }
7e0f6979 634 if (sra->array.spare_disks == 0 && backup_file == NULL) {
06b0d786 635 fprintf(stderr, Name ": %s: Cannot grow - need a spare or backup-file to backup critical section\n",
353632d9
NB
636 devname);
637 return 1;
638 }
e86c9dd6 639
7e0f6979 640 nrdisks = array.nr_disks + sra->array.spare_disks;
e86c9dd6
NB
641 /* Now we need to open all these devices so we can read/write.
642 */
06b0d786
NB
643 fdlist = malloc((1+nrdisks) * sizeof(int));
644 offsets = malloc((1+nrdisks) * sizeof(offsets[0]));
e86c9dd6
NB
645 if (!fdlist || !offsets) {
646 fprintf(stderr, Name ": malloc failed: grow aborted\n");
647 return 1;
648 }
06b0d786 649 for (d=0; d <= nrdisks; d++)
e86c9dd6
NB
650 fdlist[d] = -1;
651 d = array.raid_disks;
652 for (sd = sra->devs; sd; sd=sd->next) {
06c7f68e 653 if (sd->disk.state & (1<<MD_DISK_FAULTY))
e86c9dd6 654 continue;
06c7f68e
NB
655 if (sd->disk.state & (1<<MD_DISK_SYNC)) {
656 char *dn = map_dev(sd->disk.major,
657 sd->disk.minor, 1);
658 fdlist[sd->disk.raid_disk]
659 = dev_open(dn, O_RDONLY);
660 offsets[sd->disk.raid_disk] = sd->data_offset;
661 if (fdlist[sd->disk.raid_disk] < 0) {
e86c9dd6 662 fprintf(stderr, Name ": %s: cannot open component %s\n",
e81cdd9f 663 devname, dn?dn:"-unknown-");
e86c9dd6
NB
664 goto abort;
665 }
666 } else {
667 /* spare */
06c7f68e
NB
668 char *dn = map_dev(sd->disk.major,
669 sd->disk.minor, 1);
16c6fa80 670 fdlist[d] = dev_open(dn, O_RDWR);
06c7f68e 671 offsets[d] = sd->data_offset;
e86c9dd6
NB
672 if (fdlist[d]<0) {
673 fprintf(stderr, Name ": %s: cannot open component %s\n",
e81cdd9f 674 devname, dn?dn:"-unknown");
e86c9dd6
NB
675 goto abort;
676 }
677 d++;
678 }
679 }
680 for (i=0 ; i<array.raid_disks; i++)
681 if (fdlist[i] < 0) {
682 fprintf(stderr, Name ": %s: failed to find device %d. Array might be degraded.\n"
683 " --grow aborted\n", devname, i);
684 goto abort;
685 }
7e0f6979 686 spares = sra->array.spare_disks;
06b0d786
NB
687 if (backup_file) {
688 fdlist[d] = open(backup_file, O_RDWR|O_CREAT|O_EXCL, 0600);
689 if (fdlist[d] < 0) {
690 fprintf(stderr, Name ": %s: cannot create backup file %s: %s\n",
691 devname, backup_file, strerror(errno));
692 goto abort;
693 }
694 offsets[d] = 8;
695 d++;
696 spares++;
697 }
e86c9dd6 698 if (fdlist[array.raid_disks] < 0) {
06b0d786 699 fprintf(stderr, Name ": %s: failed to find a spare and no backup-file given - --grow aborted\n",
e86c9dd6
NB
700 devname);
701 goto abort;
702 }
703
704 /* Find a superblock */
3da92f27 705 if (st->ss->load_super(st, fdlist[0], NULL)) {
e86c9dd6
NB
706 fprintf(stderr, Name ": %s: Cannot find a superblock\n",
707 devname);
708 goto abort;
709 }
710
2efedc7b
NB
711
712 memcpy(bsb.magic, "md_backup_data-1", 16);
3da92f27 713 st->ss->uuid_from_super(st, (int*)&bsb.set_uuid);
2efedc7b
NB
714 bsb.mtime = __cpu_to_le64(time(0));
715 bsb.arraystart = 0;
716 bsb.length = __cpu_to_le64(last_block);
717
718 /* Decide offset for the backup, llseek the spares, and write
719 * a leading superblock 4K earlier.
720 */
e86c9dd6 721 for (i=array.raid_disks; i<d; i++) {
2efedc7b 722 char buf[4096];
06b0d786
NB
723 if (i==d-1 && backup_file) {
724 /* This is the backup file */
725 offsets[i] = 8;
726 } else
727 offsets[i] += sra->component_size - last_block - 8;
2efedc7b
NB
728 if (lseek64(fdlist[i], (offsets[i]<<9) - 4096, 0)
729 != (offsets[i]<<9) - 4096) {
e86c9dd6
NB
730 fprintf(stderr, Name ": could not seek...\n");
731 goto abort;
732 }
2efedc7b
NB
733 memset(buf, 0, sizeof(buf));
734 bsb.devstart = __cpu_to_le64(offsets[i]);
735 bsb.sb_csum = bsb_csum((char*)&bsb, ((char*)&bsb.sb_csum)-((char*)&bsb));
736 memcpy(buf, &bsb, sizeof(bsb));
737 if (write(fdlist[i], buf, 4096) != 4096) {
738 fprintf(stderr, Name ": could not write leading superblock\n");
739 goto abort;
740 }
e86c9dd6
NB
741 }
742 array.level = nlevel;
743 array.raid_disks = ndisks;
744 array.chunk_size = nchunk;
745 array.layout = nlayout;
746 if (ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
758d3a8e
NB
747 if (errno == ENOSPC) {
748 /* stripe cache is not big enough.
749 * It needs to be 4 times chunksize_size,
750 * and we assume pagesize is 4K
751 */
752 if (sra->cache_size < 4 * (nchunk/4096)) {
753 sysfs_set_num(sra, NULL,
754 "stripe_cache_size",
755 4 * (nchunk/4096) +1);
756 if (ioctl(fd, SET_ARRAY_INFO,
757 &array) == 0)
758 goto ok;
759 }
760 }
e86c9dd6
NB
761 fprintf(stderr, Name ": Cannot set device size/shape for %s: %s\n",
762 devname, strerror(errno));
763 goto abort;
764 }
758d3a8e 765 ok: ;
e86c9dd6
NB
766
767 /* suspend the relevant region */
768 sysfs_set_num(sra, NULL, "suspend_hi", 0); /* just in case */
769 if (sysfs_set_num(sra, NULL, "suspend_lo", 0) < 0 ||
770 sysfs_set_num(sra, NULL, "suspend_hi", last_block) < 0) {
771 fprintf(stderr, Name ": %s: failed to suspend device.\n",
772 devname);
773 goto abort_resume;
774 }
775
776
777 err = save_stripes(fdlist, offsets,
778 odisks, ochunk, olevel, olayout,
779 spares, fdlist+odisks,
06b0d786 780 0ULL, last_block*512);
e86c9dd6
NB
781
782 /* abort if there was an error */
783 if (err < 0) {
784 fprintf(stderr, Name ": %s: failed to save critical region\n",
785 devname);
786 goto abort_resume;
787 }
2efedc7b 788
e86c9dd6 789 for (i=odisks; i<d ; i++) {
353632d9 790 bsb.devstart = __cpu_to_le64(offsets[i]);
e86c9dd6 791 bsb.sb_csum = bsb_csum((char*)&bsb, ((char*)&bsb.sb_csum)-((char*)&bsb));
206c5eae 792 if (lseek64(fdlist[i], (offsets[i]+last_block)<<9, 0) < 0 ||
06b0d786
NB
793 write(fdlist[i], &bsb, sizeof(bsb)) != sizeof(bsb) ||
794 fsync(fdlist[i]) != 0) {
206c5eae
NB
795 fprintf(stderr, Name ": %s: fail to save metadata for critical region backups.\n",
796 devname);
797 goto abort_resume;
798 }
e86c9dd6
NB
799 }
800
801 /* start the reshape happening */
802 if (sysfs_set_str(sra, NULL, "sync_action", "reshape") < 0) {
803 fprintf(stderr, Name ": %s: failed to initiate reshape\n",
804 devname);
805 goto abort_resume;
806 }
807 /* wait for reshape to pass the critical region */
808 while(1) {
809 unsigned long long comp;
206c5eae
NB
810 if (sysfs_get_ll(sra, NULL, "sync_completed", &comp)<0) {
811 sleep(5);
e86c9dd6 812 break;
206c5eae 813 }
e86c9dd6
NB
814 if (comp >= nstripe)
815 break;
816 sleep(1);
817 }
aba69144 818
e86c9dd6
NB
819 /* invalidate superblocks */
820 memset(&bsb, 0, sizeof(bsb));
821 for (i=odisks; i<d ; i++) {
822 lseek64(fdlist[i], (offsets[i]+last_block)<<9, 0);
9fca7d62
NB
823 if (write(fdlist[i], &bsb, sizeof(bsb)) < 0) {
824 fprintf(stderr, Name ": %s: failed to invalidate metadata for raid disk %d\n",
825 devname, i);
826 }
e86c9dd6
NB
827 }
828
829 /* unsuspend. */
830 sysfs_set_num(sra, NULL, "suspend_lo", last_block);
831
832 for (i=0; i<d; i++)
833 if (fdlist[i] >= 0)
834 close(fdlist[i]);
835 free(fdlist);
836 free(offsets);
06b0d786
NB
837 if (backup_file)
838 unlink(backup_file);
e86c9dd6 839
206c5eae 840 printf(Name ": ... critical section passed.\n");
e86c9dd6
NB
841 break;
842 }
843 return 0;
844
845
846 abort_resume:
847 sysfs_set_num(sra, NULL, "suspend_lo", last_block);
848 abort:
849 for (i=0; i<array.nr_disks; i++)
850 if (fdlist[i] >= 0)
851 close(fdlist[i]);
852 free(fdlist);
853 free(offsets);
06b0d786
NB
854 if (backup_file)
855 unlink(backup_file);
e86c9dd6
NB
856 return 1;
857
858}
353632d9
NB
859
860/*
861 * If any spare contains md_back_data-1 which is recent wrt mtime,
862 * write that data into the array and update the super blocks with
863 * the new reshape_progress
864 */
06b0d786 865int Grow_restart(struct supertype *st, struct mdinfo *info, int *fdlist, int cnt, char *backup_file)
353632d9
NB
866{
867 int i, j;
868 int old_disks;
353632d9 869 unsigned long long *offsets;
6e9eac4f
NB
870 unsigned long long nstripe, ostripe, last_block;
871 int ndata, odata;
353632d9
NB
872
873 if (info->delta_disks < 0)
874 return 1; /* cannot handle a shrink */
875 if (info->new_level != info->array.level ||
876 info->new_layout != info->array.layout ||
877 info->new_chunk != info->array.chunk_size)
878 return 1; /* Can only handle change in disks */
879
880 old_disks = info->array.raid_disks - info->delta_disks;
881
06b0d786 882 for (i=old_disks-(backup_file?1:0); i<cnt; i++) {
353632d9 883 struct mdinfo dinfo;
353632d9 884 struct mdp_backup_super bsb;
2efedc7b 885 char buf[4096];
06b0d786 886 int fd;
353632d9
NB
887
888 /* This was a spare and may have some saved data on it.
889 * Load the superblock, find and load the
890 * backup_super_block.
891 * If either fail, go on to next device.
892 * If the backup contains no new info, just return
206c5eae 893 * else restore data and update all superblocks
353632d9 894 */
06b0d786
NB
895 if (i == old_disks-1) {
896 fd = open(backup_file, O_RDONLY);
897 if (fd<0)
898 continue;
06b0d786
NB
899 } else {
900 fd = fdlist[i];
901 if (fd < 0)
902 continue;
3da92f27 903 if (st->ss->load_super(st, fd, NULL))
06b0d786 904 continue;
353632d9 905
3da92f27
NB
906 st->ss->getinfo_super(st, &dinfo);
907 st->ss->free_super(st);
908
06b0d786
NB
909 if (lseek64(fd,
910 (dinfo.data_offset + dinfo.component_size - 8) <<9,
911 0) < 0)
912 continue; /* Cannot seek */
913 }
914 if (read(fd, &bsb, sizeof(bsb)) != sizeof(bsb))
353632d9
NB
915 continue; /* Cannot read */
916 if (memcmp(bsb.magic, "md_backup_data-1", 16) != 0)
917 continue;
918 if (bsb.sb_csum != bsb_csum((char*)&bsb, ((char*)&bsb.sb_csum)-((char*)&bsb)))
919 continue; /* bad checksum */
920 if (memcmp(bsb.set_uuid,info->uuid, 16) != 0)
921 continue; /* Wrong uuid */
922
923 if (info->array.utime > __le64_to_cpu(bsb.mtime) + 3600 ||
924 info->array.utime < __le64_to_cpu(bsb.mtime))
925 continue; /* time stamp is too bad */
926
927 if (__le64_to_cpu(bsb.arraystart) != 0)
928 continue; /* Can only handle backup from start of array */
929 if (__le64_to_cpu(bsb.length) <
930 info->reshape_progress)
931 continue; /* No new data here */
932
06b0d786 933 if (lseek64(fd, __le64_to_cpu(bsb.devstart)*512, 0)< 0)
353632d9 934 continue; /* Cannot seek */
2efedc7b 935 /* There should be a duplicate backup superblock 4k before here */
06b0d786
NB
936 if (lseek64(fd, -4096, 1) < 0 ||
937 read(fd, buf, 4096) != 4096 ||
9860f271 938 memcmp(buf, &bsb, sizeof(bsb)) != 0)
2efedc7b
NB
939 continue; /* Cannot find leading superblock */
940
353632d9
NB
941 /* Now need the data offsets for all devices. */
942 offsets = malloc(sizeof(*offsets)*info->array.raid_disks);
943 for(j=0; j<info->array.raid_disks; j++) {
944 if (fdlist[j] < 0)
945 continue;
3da92f27 946 if (st->ss->load_super(st, fdlist[j], NULL))
353632d9
NB
947 /* FIXME should be this be an error */
948 continue;
3da92f27
NB
949 st->ss->getinfo_super(st, &dinfo);
950 st->ss->free_super(st);
353632d9
NB
951 offsets[j] = dinfo.data_offset;
952 }
953 printf(Name ": restoring critical section\n");
954
955 if (restore_stripes(fdlist, offsets,
956 info->array.raid_disks,
957 info->new_chunk,
958 info->new_level,
959 info->new_layout,
06b0d786 960 fd, __le64_to_cpu(bsb.devstart)*512,
353632d9
NB
961 0, __le64_to_cpu(bsb.length)*512)) {
962 /* didn't succeed, so giveup */
2295250a 963 return 1;
353632d9
NB
964 }
965
966 /* Ok, so the data is restored. Let's update those superblocks. */
967
968 for (j=0; j<info->array.raid_disks; j++) {
969 if (fdlist[j] < 0) continue;
3da92f27 970 if (st->ss->load_super(st, fdlist[j], NULL))
353632d9 971 continue;
3da92f27 972 st->ss->getinfo_super(st, &dinfo);
353632d9 973 dinfo.reshape_progress = __le64_to_cpu(bsb.length);
3da92f27 974 st->ss->update_super(st, &dinfo,
68c7d6d7
NB
975 "_reshape_progress",
976 NULL,0, 0, NULL);
3da92f27
NB
977 st->ss->store_super(st, fdlist[j]);
978 st->ss->free_super(st);
353632d9
NB
979 }
980
981 /* And we are done! */
982 return 0;
983 }
6e9eac4f
NB
984 /* Didn't find any backup data, try to see if any
985 * was needed.
986 */
987 nstripe = ostripe = 0;
988 odata = info->array.raid_disks - info->delta_disks - 1;
989 if (info->array.level == 6) odata--; /* number of data disks */
990 ndata = info->array.raid_disks - 1;
991 if (info->new_level == 6) ndata--;
992 last_block = 0;
993 while (nstripe >= ostripe) {
994 nstripe += info->new_chunk / 512;
995 last_block = nstripe * ndata;
996 ostripe = last_block / odata / (info->array.chunk_size/512) *
997 (info->array.chunk_size/512);
998 }
999
1000 if (info->reshape_progress >= last_block)
1001 return 0;
1002 /* needed to recover critical section! */
2295250a 1003 return 1;
353632d9 1004}