]> git.ipfire.org Git - thirdparty/mdadm.git/blob - Incremental.c
projects / thirdparty / mdadm.git / blob
? search:


4c6a2a7949a3d5dd222795a782b7aaa4734bdb46
[thirdparty/mdadm.git] / Incremental.c
1 /*
2 * Incremental.c - support --incremental. Part of:
3 * mdadm - manage Linux "md" devices aka RAID arrays.
4 *
5 * Copyright (C) 2006 Neil Brown <neilb@suse.de>
6 *
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 * Author: Neil Brown
23 * Email: <neilb@suse.de>
24 * Paper: Neil Brown
25 * Novell Inc
26 * GPO Box Q1283
27 * QVB Post Office, NSW 1230
28 * Australia
29 */
30
31 #include "mdadm.h"
32
33 static int count_active(struct supertype *st, int mdfd, char **availp,
34 struct mdinfo *info);
35 static void find_reject(int mdfd, struct supertype *st, struct mdinfo *sra,
36 int number, __u64 events, int verbose,
37 char *array_name);
38
39 int Incremental(char *devname, int verbose, int runstop,
40 struct supertype *st, char *homehost, int autof)
41 {
42 /* Add this device to an array, creating the array if necessary
43 * and starting the array if sensibe or - if runstop>0 - if possible.
44 *
45 * This has several steps:
46 *
47 * 1/ Check if device is permitted by mdadm.conf, reject if not.
48 * 2/ Find metadata, reject if none appropriate (check
49 * version/name from args)
50 * 3/ Check if there is a match in mdadm.conf
51 * 3a/ if not, check for homehost match. If no match, reject.
52 * 4/ Determine device number.
53 * - If in mdadm.conf with std name, use that
54 * - UUID in /var/run/mdadm.map use that
55 * - If name is suggestive, use that. unless in use with different uuid.
56 * - Choose a free, high number.
57 * - Use a partitioned device unless strong suggestion not to.
58 * e.g. auto=md
59 * 5/ Find out if array already exists
60 * 5a/ if it does not
61 * - choose a name, from mdadm.conf or 'name' field in array.
62 * - create the array
63 * - add the device
64 * 5b/ if it does
65 * - check one drive in array to make sure metadata is a reasonably
66 * close match. Reject if not (e.g. different type)
67 * - add the device
68 * 6/ Make sure /var/run/mdadm.map contains this array.
69 * 7/ Is there enough devices to possibly start the array?
70 * 7a/ if not, finish with success.
71 * 7b/ if yes,
72 * - read all metadata and arrange devices like -A does
73 * - if number of OK devices match expected, or -R and there are enough,
74 * start the array (auto-readonly).
75 */
76 struct stat stb;
77 struct mdinfo info, info2;
78 struct mddev_ident_s *array_list, *match;
79 char chosen_name[1024];
80 int rv;
81 int devnum;
82 struct map_ent *mp, *map = NULL;
83 int dfd, mdfd;
84 char *avail;
85 int active_disks;
86
87
88 struct createinfo *ci = conf_get_create_info();
89
90 if (autof == 0)
91 autof = ci->autof;
92
93 /* 1/ Check if devices is permitted by mdadm.conf */
94
95 if (!conf_test_dev(devname)) {
96 if (verbose >= 0)
97 fprintf(stderr, Name
98 ": %s not permitted by mdadm.conf.\n",
99 devname);
100 return 1;
101 }
102
103 /* 2/ Find metadata, reject if none appropriate (check
104 * version/name from args) */
105
106 dfd = dev_open(devname, O_RDONLY|O_EXCL);
107 if (dfd < 0) {
108 if (verbose >= 0)
109 fprintf(stderr, Name ": cannot open %s: %s.\n",
110 devname, strerror(errno));
111 return 1;
112 }
113 if (fstat(dfd, &stb) < 0) {
114 if (verbose >= 0)
115 fprintf(stderr, Name ": fstat failed for %s: %s.\n",
116 devname, strerror(errno));
117 close(dfd);
118 return 1;
119 }
120 if ((stb.st_mode & S_IFMT) != S_IFBLK) {
121 if (verbose >= 0)
122 fprintf(stderr, Name ": %s is not a block device.\n",
123 devname);
124 close(dfd);
125 return 1;
126 }
127
128 if (st == NULL && (st = guess_super(dfd)) == NULL) {
129 if (verbose >= 0)
130 fprintf(stderr, Name
131 ": no recognisable superblock on %s.\n",
132 devname);
133 close(dfd);
134 return 1;
135 }
136 if (st->ss->load_super(st, dfd, NULL)) {
137 if (verbose >= 0)
138 fprintf(stderr, Name ": no RAID superblock on %s.\n",
139 devname);
140 close(dfd);
141 return 1;
142 }
143 st->ss->getinfo_super(st, &info);
144 close (dfd);
145
146 /* 3/ Check if there is a match in mdadm.conf */
147
148 array_list = conf_get_ident(NULL);
149 match = NULL;
150 for (; array_list; array_list = array_list->next) {
151 if (array_list->uuid_set &&
152 same_uuid(array_list->uuid, info.uuid, st->ss->swapuuid)
153 == 0) {
154 if (verbose >= 2)
155 fprintf(stderr, Name
156 ": UUID differs from %s.\n",
157 array_list->devname);
158 continue;
159 }
160 if (array_list->name[0] &&
161 strcasecmp(array_list->name, info.name) != 0) {
162 if (verbose >= 2)
163 fprintf(stderr, Name
164 ": Name differs from %s.\n",
165 array_list->devname);
166 continue;
167 }
168 if (array_list->devices &&
169 !match_oneof(array_list->devices, devname)) {
170 if (verbose >= 2)
171 fprintf(stderr, Name
172 ": Not a listed device for %s.\n",
173 array_list->devname);
174 continue;
175 }
176 if (array_list->super_minor != UnSet &&
177 array_list->super_minor != info.array.md_minor) {
178 if (verbose >= 2)
179 fprintf(stderr, Name
180 ": Different super-minor to %s.\n",
181 array_list->devname);
182 continue;
183 }
184 if (!array_list->uuid_set &&
185 !array_list->name[0] &&
186 !array_list->devices &&
187 array_list->super_minor == UnSet) {
188 if (verbose >= 2)
189 fprintf(stderr, Name
190 ": %s doesn't have any identifying information.\n",
191 array_list->devname);
192 continue;
193 }
194 /* FIXME, should I check raid_disks and level too?? */
195
196 if (match) {
197 if (verbose >= 0)
198 fprintf(stderr, Name
199 ": we match both %s and %s - cannot decide which to use.\n",
200 match->devname, array_list->devname);
201 return 2;
202 }
203 match = array_list;
204 }
205
206 /* 3a/ if not, check for homehost match. If no match, reject. */
207 if (!match) {
208 if (homehost == NULL ||
209 st->ss->match_home(st, homehost) == 0) {
210 if (verbose >= 0)
211 fprintf(stderr, Name
212 ": not found in mdadm.conf and not identified by homehost.\n");
213 return 2;
214 }
215 }
216 /* 4/ Determine device number. */
217 /* - If in mdadm.conf with std name, use that */
218 /* - UUID in /var/run/mdadm.map use that */
219 /* - If name is suggestive, use that. unless in use with */
220 /* different uuid. */
221 /* - Choose a free, high number. */
222 /* - Use a partitioned device unless strong suggestion not to. */
223 /* e.g. auto=md */
224 if (match && is_standard(match->devname, &devnum))
225 /* We have devnum now */;
226 else if ((mp = map_by_uuid(&map, info.uuid)) != NULL)
227 devnum = mp->devnum;
228 else {
229 /* Have to guess a bit. */
230 int use_partitions = 1;
231 char *np, *ep;
232 if ((autof&7) == 3 || (autof&7) == 5)
233 use_partitions = 0;
234 np = strchr(info.name, ':');
235 if (np)
236 np++;
237 else
238 np = info.name;
239 devnum = strtoul(np, &ep, 10);
240 if (ep > np && *ep == 0) {
241 /* This is a number. Let check that it is unused. */
242 if (mddev_busy(use_partitions ? (-1-devnum) : devnum))
243 devnum = -1;
244 } else
245 devnum = -1;
246
247 if (devnum < 0) {
248 /* Haven't found anything yet, choose something free */
249 /* There is similar code in mdopen.c - should unify */
250 for (devnum = 127 ; devnum != 128 ;
251 devnum = devnum ? devnum-1 : (1<<22)-1) {
252 if (mddev_busy(use_partitions ?
253 (-1-devnum) : devnum))
254 break;
255 }
256 if (devnum == 128) {
257 fprintf(stderr, Name
258 ": No spare md devices!!\n");
259 return 2;
260 }
261 }
262 devnum = use_partitions ? (-1-devnum) : devnum;
263 }
264 mdfd = open_mddev_devnum(match ? match->devname : NULL,
265 devnum,
266 info.name,
267 chosen_name);
268 if (mdfd < 0) {
269 fprintf(stderr, Name ": failed to open %s: %s.\n",
270 chosen_name, strerror(errno));
271 return 2;
272 }
273 /* 5/ Find out if array already exists */
274 if (! mddev_busy(devnum)) {
275 /* 5a/ if it does not */
276 /* - choose a name, from mdadm.conf or 'name' field in array. */
277 /* - create the array */
278 /* - add the device */
279 mdu_array_info_t ainf;
280 mdu_disk_info_t disk;
281 char md[20];
282 struct mdinfo *sra;
283
284 memset(&ainf, 0, sizeof(ainf));
285 ainf.major_version = st->ss->major;
286 ainf.minor_version = st->minor_version;
287 if (ioctl(mdfd, SET_ARRAY_INFO, &ainf) != 0) {
288 fprintf(stderr, Name
289 ": SET_ARRAY_INFO failed for %s: %s\b",
290 chosen_name, strerror(errno));
291 close(mdfd);
292 return 2;
293 }
294 sprintf(md, "%d.%d\n", st->ss->major, st->minor_version);
295 sra = sysfs_read(mdfd, devnum, GET_VERSION);
296 sysfs_set_str(sra, NULL, "metadata_version", md);
297 memset(&disk, 0, sizeof(disk));
298 disk.major = major(stb.st_rdev);
299 disk.minor = minor(stb.st_rdev);
300 sysfs_free(sra);
301 if (ioctl(mdfd, ADD_NEW_DISK, &disk) != 0) {
302 fprintf(stderr, Name ": failed to add %s to %s: %s.\n",
303 devname, chosen_name, strerror(errno));
304 ioctl(mdfd, STOP_ARRAY, 0);
305 close(mdfd);
306 return 2;
307 }
308 sra = sysfs_read(mdfd, devnum, GET_DEVS);
309 if (!sra || !sra->devs || sra->devs->disk.raid_disk >= 0) {
310 /* It really should be 'none' - must be old buggy
311 * kernel, and mdadm -I may not be able to complete.
312 * So reject it.
313 */
314 ioctl(mdfd, STOP_ARRAY, NULL);
315 fprintf(stderr, Name
316 ": You have an old buggy kernel which cannot support\n"
317 " --incremental reliably. Aborting.\n");
318 close(mdfd);
319 sysfs_free(sra);
320 return 2;
321 }
322 } else {
323 /* 5b/ if it does */
324 /* - check one drive in array to make sure metadata is a reasonably */
325 /* close match. Reject if not (e.g. different type) */
326 /* - add the device */
327 char dn[20];
328 int dfd2;
329 mdu_disk_info_t disk;
330 int err;
331 struct mdinfo *sra;
332 struct supertype *st2;
333 sra = sysfs_read(mdfd, devnum, (GET_VERSION | GET_DEVS |
334 GET_STATE));
335
336 if (sra->array.major_version != st->ss->major ||
337 sra->array.minor_version != st->minor_version) {
338 if (verbose >= 0)
339 fprintf(stderr, Name
340 ": %s has different metadata to chosen array %s %d.%d %d.%d.\n",
341 devname, chosen_name,
342 sra->array.major_version,
343 sra->array.minor_version,
344 st->ss->major, st->minor_version);
345 close(mdfd);
346 return 1;
347 }
348 sprintf(dn, "%d:%d", sra->devs->disk.major,
349 sra->devs->disk.minor);
350 dfd2 = dev_open(dn, O_RDONLY);
351 st2 = dup_super(st);
352 if (st2->ss->load_super(st2, dfd2, NULL)) {
353 fprintf(stderr, Name
354 ": Strange error loading metadata for %s.\n",
355 chosen_name);
356 close(mdfd);
357 close(dfd2);
358 return 2;
359 }
360 close(dfd2);
361 st2->ss->getinfo_super(st2, &info2);
362 st2->ss->free_super(st2);
363 if (info.array.level != info2.array.level ||
364 memcmp(info.uuid, info2.uuid, 16) != 0 ||
365 info.array.raid_disks != info2.array.raid_disks) {
366 fprintf(stderr, Name
367 ": unexpected difference between %s and %s.\n",
368 chosen_name, devname);
369 close(mdfd);
370 return 2;
371 }
372 memset(&disk, 0, sizeof(disk));
373 disk.major = major(stb.st_rdev);
374 disk.minor = minor(stb.st_rdev);
375 err = ioctl(mdfd, ADD_NEW_DISK, &disk);
376 if (err < 0 && errno == EBUSY) {
377 /* could be another device present with the same
378 * disk.number. Find and reject any such
379 */
380 find_reject(mdfd, st, sra, info.disk.number,
381 info.events, verbose, chosen_name);
382 err = ioctl(mdfd, ADD_NEW_DISK, &disk);
383 }
384 if (err < 0) {
385 fprintf(stderr, Name ": failed to add %s to %s: %s.\n",
386 devname, chosen_name, strerror(errno));
387 close(mdfd);
388 return 2;
389 }
390 }
391 /* 6/ Make sure /var/run/mdadm.map contains this array. */
392 map_update(&map, devnum,
393 info.array.major_version,
394 info.array.minor_version,
395 info.uuid, chosen_name);
396
397 /* 7/ Is there enough devices to possibly start the array? */
398 /* 7a/ if not, finish with success. */
399 avail = NULL;
400 active_disks = count_active(st, mdfd, &avail, &info);
401 if (enough(info.array.level, info.array.raid_disks,
402 info.array.layout, info.array.state & 1,
403 avail, active_disks) == 0) {
404 free(avail);
405 if (verbose >= 0)
406 fprintf(stderr, Name
407 ": %s attached to %s, not enough to start (%d).\n",
408 devname, chosen_name, active_disks);
409 close(mdfd);
410 return 0;
411 }
412 free(avail);
413
414 /* 7b/ if yes, */
415 /* - if number of OK devices match expected, or -R and there */
416 /* are enough, */
417 /* + add any bitmap file */
418 /* + start the array (auto-readonly). */
419 {
420 mdu_array_info_t ainf;
421
422 if (ioctl(mdfd, GET_ARRAY_INFO, &ainf) == 0) {
423 if (verbose >= 0)
424 fprintf(stderr, Name
425 ": %s attached to %s which is already active.\n",
426 devname, chosen_name);
427 close (mdfd);
428 return 0;
429 }
430 }
431 if (runstop > 0 || active_disks >= info.array.working_disks) {
432 struct mdinfo *sra;
433 /* Let's try to start it */
434 if (match && match->bitmap_file) {
435 int bmfd = open(match->bitmap_file, O_RDWR);
436 if (bmfd < 0) {
437 fprintf(stderr, Name
438 ": Could not open bitmap file %s.\n",
439 match->bitmap_file);
440 close(mdfd);
441 return 1;
442 }
443 if (ioctl(mdfd, SET_BITMAP_FILE, bmfd) != 0) {
444 close(bmfd);
445 fprintf(stderr, Name
446 ": Failed to set bitmapfile for %s.\n",
447 chosen_name);
448 close(mdfd);
449 return 1;
450 }
451 close(bmfd);
452 }
453 sra = sysfs_read(mdfd, devnum, 0);
454 if (sra == NULL || active_disks >= info.array.working_disks)
455 rv = ioctl(mdfd, RUN_ARRAY, NULL);
456 else
457 rv = sysfs_set_str(sra, NULL,
458 "array_state", "read-auto");
459 if (rv == 0) {
460 if (verbose >= 0)
461 fprintf(stderr, Name
462 ": %s attached to %s, which has been started.\n",
463 devname, chosen_name);
464 rv = 0;
465 } else {
466 fprintf(stderr, Name
467 ": %s attached to %s, but failed to start: %s.\n",
468 devname, chosen_name, strerror(errno));
469 rv = 1;
470 }
471 } else {
472 if (verbose >= 0)
473 fprintf(stderr, Name
474 ": %s attached to %s, not enough to start safely.\n",
475 devname, chosen_name);
476 rv = 0;
477 }
478 close(mdfd);
479 return rv;
480 }
481
482 static void find_reject(int mdfd, struct supertype *st, struct mdinfo *sra,
483 int number, __u64 events, int verbose,
484 char *array_name)
485 {
486 /* Find a device attached to this array with a disk.number of number
487 * and events less than the passed events, and remove the device.
488 */
489 struct mdinfo *d;
490 mdu_array_info_t ra;
491
492 if (ioctl(mdfd, GET_ARRAY_INFO, &ra) == 0)
493 return; /* not safe to remove from active arrays
494 * without thinking more */
495
496 for (d = sra->devs; d ; d = d->next) {
497 char dn[10];
498 int dfd;
499 struct mdinfo info;
500 sprintf(dn, "%d:%d", d->disk.major, d->disk.minor);
501 dfd = dev_open(dn, O_RDONLY);
502 if (dfd < 0)
503 continue;
504 if (st->ss->load_super(st, dfd, NULL)) {
505 close(dfd);
506 continue;
507 }
508 st->ss->getinfo_super(st, &info);
509 st->ss->free_super(st);
510 close(dfd);
511
512 if (info.disk.number != number ||
513 info.events >= events)
514 continue;
515
516 if (d->disk.raid_disk > -1)
517 sysfs_set_str(sra, d, "slot", "none");
518 if (sysfs_set_str(sra, d, "state", "remove") == 0)
519 if (verbose >= 0)
520 fprintf(stderr, Name
521 ": removing old device %s from %s\n",
522 d->sys_name+4, array_name);
523 }
524 }
525
526 static int count_active(struct supertype *st, int mdfd, char **availp,
527 struct mdinfo *bestinfo)
528 {
529 /* count how many devices in sra think they are active */
530 struct mdinfo *d;
531 int cnt = 0, cnt1 = 0;
532 __u64 max_events = 0;
533 struct mdinfo *sra = sysfs_read(mdfd, -1, GET_DEVS | GET_STATE);
534 char *avail = NULL;
535
536 for (d = sra->devs ; d ; d = d->next) {
537 char dn[30];
538 int dfd;
539 int ok;
540 struct mdinfo info;
541
542 sprintf(dn, "%d:%d", d->disk.major, d->disk.minor);
543 dfd = dev_open(dn, O_RDONLY);
544 if (dfd < 0)
545 continue;
546 ok = st->ss->load_super(st, dfd, NULL);
547 close(dfd);
548 if (ok != 0)
549 continue;
550 st->ss->getinfo_super(st, &info);
551 if (info.disk.state & (1<<MD_DISK_SYNC))
552 {
553 if (avail == NULL) {
554 avail = malloc(info.array.raid_disks);
555 memset(avail, 0, info.array.raid_disks);
556 }
557 if (cnt == 0) {
558 cnt++;
559 max_events = info.events;
560 avail[info.disk.raid_disk] = 2;
561 st->ss->getinfo_super(st, bestinfo);
562 } else if (info.events == max_events) {
563 cnt++;
564 avail[info.disk.raid_disk] = 2;
565 } else if (info.events == max_events-1) {
566 cnt1++;
567 avail[info.disk.raid_disk] = 1;
568 } else if (info.events < max_events - 1)
569 ;
570 else if (info.events == max_events+1) {
571 int i;
572 cnt1 = cnt;
573 cnt = 1;
574 max_events = info.events;
575 for (i=0; i<info.array.raid_disks; i++)
576 if (avail[i])
577 avail[i]--;
578 avail[info.disk.raid_disk] = 2;
579 st->ss->getinfo_super(st, bestinfo);
580 } else { /* info.events much bigger */
581 cnt = 1; cnt1 = 0;
582 memset(avail, 0, info.disk.raid_disk);
583 max_events = info.events;
584 st->ss->getinfo_super(st, bestinfo);
585 }
586 }
587 st->ss->free_super(st);
588 }
589 return cnt + cnt1;
590 }
591
592 void RebuildMap(void)
593 {
594 struct mdstat_ent *mdstat = mdstat_read(0, 0);
595 struct mdstat_ent *md;
596 struct map_ent *map = NULL;
597 int mdp = get_mdp_major();
598
599 for (md = mdstat ; md ; md = md->next) {
600 struct mdinfo *sra = sysfs_read(-1, md->devnum, GET_DEVS);
601 struct mdinfo *sd;
602
603 for (sd = sra->devs ; sd ; sd = sd->next) {
604 char dn[30];
605 int dfd;
606 int ok;
607 struct supertype *st;
608 char *path;
609 struct mdinfo info;
610
611 sprintf(dn, "%d:%d", sd->disk.major, sd->disk.minor);
612 dfd = dev_open(dn, O_RDONLY);
613 if (dfd < 0)
614 continue;
615 st = guess_super(dfd);
616 if ( st == NULL)
617 ok = -1;
618 else
619 ok = st->ss->load_super(st, dfd, NULL);
620 close(dfd);
621 if (ok != 0)
622 continue;
623 st->ss->getinfo_super(st, &info);
624 if (md->devnum > 0)
625 path = map_dev(MD_MAJOR, md->devnum, 0);
626 else
627 path = map_dev(mdp, (-1-md->devnum)<< 6, 0);
628 map_add(&map, md->devnum, st->ss->major,
629 st->minor_version,
630 info.uuid, path ? : "/unknown");
631 st->ss->free_super(st);
632 break;
633 }
634 }
635 map_write(map);
636 map_free(map);
637 }
638
639 int IncrementalScan(int verbose)
640 {
641 /* look at every device listed in the 'map' file.
642 * If one is found that is not running then:
643 * look in mdadm.conf for bitmap file.
644 * if one exists, but array has none, add it.
645 * try to start array in auto-readonly mode
646 */
647 struct map_ent *mapl = NULL;
648 struct map_ent *me;
649 mddev_ident_t devs, mddev;
650 int rv = 0;
651
652 map_read(&mapl);
653 devs = conf_get_ident(NULL);
654
655 for (me = mapl ; me ; me = me->next) {
656 char path[1024];
657 mdu_array_info_t array;
658 mdu_bitmap_file_t bmf;
659 struct mdinfo *sra;
660 int mdfd = open_mddev_devnum(me->path, me->devnum, NULL, path);
661 if (mdfd < 0)
662 continue;
663 if (ioctl(mdfd, GET_ARRAY_INFO, &array) == 0 ||
664 errno != ENODEV) {
665 close(mdfd);
666 continue;
667 }
668 /* Ok, we can try this one. Maybe it needs a bitmap */
669 for (mddev = devs ; mddev ; mddev = mddev->next)
670 if (strcmp(mddev->devname, me->path) == 0)
671 break;
672 if (mddev && mddev->bitmap_file) {
673 /*
674 * Note: early kernels will wrongly fail this, so it
675 * is a hint only
676 */
677 int added = -1;
678 if (ioctl(mdfd, GET_ARRAY_INFO, &bmf) < 0) {
679 int bmfd = open(mddev->bitmap_file, O_RDWR);
680 if (bmfd >= 0) {
681 added = ioctl(mdfd, SET_BITMAP_FILE,
682 bmfd);
683 close(bmfd);
684 }
685 }
686 if (verbose >= 0) {
687 if (added == 0)
688 fprintf(stderr, Name
689 ": Added bitmap %s to %s\n",
690 mddev->bitmap_file, me->path);
691 else if (errno != EEXIST)
692 fprintf(stderr, Name
693 ": Failed to add bitmap to %s: %s\n",
694 me->path, strerror(errno));
695 }
696 }
697 sra = sysfs_read(mdfd, 0, 0);
698 if (sra) {
699 if (sysfs_set_str(sra, NULL,
700 "array_state", "read-auto") == 0) {
701 if (verbose >= 0)
702 fprintf(stderr, Name
703 ": started array %s\n",
704 me->path);
705 } else {
706 fprintf(stderr, Name
707 ": failed to start array %s: %s\n",
708 me->path, strerror(errno));
709 rv = 1;
710 }
711 }
712 }
713 return rv;
714 }
Unnamed repository; edit this file 'description' to name the repository.