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