Use new container_content rather than passing subarray to load_super.
[thirdparty/mdadm.git] / util.c
1 /*
2  * mdadm - manage Linux "md" devices aka RAID arrays.
3  *
4  * Copyright (C) 2001-2009 Neil Brown <neilb@suse.de>
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        "mdadm.h"
26 #include        "md_p.h"
27 #include        <sys/socket.h>
28 #include        <sys/utsname.h>
29 #include        <sys/wait.h>
30 #include        <sys/un.h>
31 #include        <ctype.h>
32 #include        <dirent.h>
33 #include        <signal.h>
34
35 /*
36  * following taken from linux/blkpg.h because they aren't
37  * anywhere else and it isn't safe to #include linux/ * stuff.
38  */
39
40 #define BLKPG      _IO(0x12,105)
41
42 /* The argument structure */
43 struct blkpg_ioctl_arg {
44         int op;
45         int flags;
46         int datalen;
47         void *data;
48 };
49
50 /* The subfunctions (for the op field) */
51 #define BLKPG_ADD_PARTITION     1
52 #define BLKPG_DEL_PARTITION     2
53
54 /* Sizes of name fields. Unused at present. */
55 #define BLKPG_DEVNAMELTH        64
56 #define BLKPG_VOLNAMELTH        64
57
58 /* The data structure for ADD_PARTITION and DEL_PARTITION */
59 struct blkpg_partition {
60         long long start;                /* starting offset in bytes */
61         long long length;               /* length in bytes */
62         int pno;                        /* partition number */
63         char devname[BLKPG_DEVNAMELTH]; /* partition name, like sda5 or c0d1p2,
64                                            to be used in kernel messages */
65         char volname[BLKPG_VOLNAMELTH]; /* volume label */
66 };
67
68 #include "part.h"
69
70 /* Force a compilation error if condition is true */
71 #define BUILD_BUG_ON(condition) ((void)BUILD_BUG_ON_ZERO(condition))
72
73 /* Force a compilation error if condition is true, but also produce a
74    result (of value 0 and type size_t), so the expression can be used
75    e.g. in a structure initializer (or where-ever else comma expressions
76    aren't permitted). */
77 #define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:-!!(e); }))
78
79 /*
80  * Parse a 128 bit uuid in 4 integers
81  * format is 32 hexx nibbles with options :.<space> separator
82  * If not exactly 32 hex digits are found, return 0
83  * else return 1
84  */
85 int parse_uuid(char *str, int uuid[4])
86 {
87         int hit = 0; /* number of Hex digIT */
88         int i;
89         char c;
90         for (i=0; i<4; i++) uuid[i]=0;
91
92         while ((c= *str++)) {
93                 int n;
94                 if (c>='0' && c<='9')
95                         n = c-'0';
96                 else if (c>='a' && c <= 'f')
97                         n = 10 + c - 'a';
98                 else if (c>='A' && c <= 'F')
99                         n = 10 + c - 'A';
100                 else if (strchr(":. -", c))
101                         continue;
102                 else return 0;
103
104                 if (hit<32) {
105                         uuid[hit/8] <<= 4;
106                         uuid[hit/8] += n;
107                 }
108                 hit++;
109         }
110         if (hit == 32)
111                 return 1;
112         return 0;
113 }
114
115
116 /*
117  * Get the md version number.
118  * We use the RAID_VERSION ioctl if it is supported
119  * If not, but we have a block device with major '9', we assume
120  * 0.36.0
121  *
122  * Return version number as 24 but number - assume version parts
123  * always < 255
124  */
125
126 int md_get_version(int fd)
127 {
128     struct stat stb;
129     mdu_version_t vers;
130
131     if (fstat(fd, &stb)<0)
132         return -1;
133     if ((S_IFMT&stb.st_mode) != S_IFBLK)
134         return -1;
135
136     if (ioctl(fd, RAID_VERSION, &vers) == 0)
137         return  (vers.major*10000) + (vers.minor*100) + vers.patchlevel;
138     if (errno == EACCES)
139             return -1;
140     if (major(stb.st_rdev) == MD_MAJOR)
141         return (3600);
142     return -1;
143 }
144
145 int get_linux_version()
146 {
147         struct utsname name;
148         char *cp;
149         int a,b,c;
150         if (uname(&name) <0)
151                 return -1;
152
153         cp = name.release;
154         a = strtoul(cp, &cp, 10);
155         if (*cp != '.') return -1;
156         b = strtoul(cp+1, &cp, 10);
157         if (*cp != '.') return -1;
158         c = strtoul(cp+1, NULL, 10);
159
160         return (a*1000000)+(b*1000)+c;
161 }
162
163 #ifndef MDASSEMBLE
164 long long parse_size(char *size)
165 {
166         /* parse 'size' which should be a number optionally
167          * followed by 'K', 'M', or 'G'.
168          * Without a suffix, K is assumed.
169          * Number returned is in sectors (half-K)
170          */
171         char *c;
172         long long s = strtoll(size, &c, 10);
173         if (s > 0) {
174                 switch (*c) {
175                 case 'K':
176                         c++;
177                 default:
178                         s *= 2;
179                         break;
180                 case 'M':
181                         c++;
182                         s *= 1024 * 2;
183                         break;
184                 case 'G':
185                         c++;
186                         s *= 1024 * 1024 * 2;
187                         break;
188                 }
189         }
190         if (*c)
191                 s = 0;
192         return s;
193 }
194
195 int parse_layout_10(char *layout)
196 {
197         int copies, rv;
198         char *cp;
199         /* Parse the layout string for raid10 */
200         /* 'f', 'o' or 'n' followed by a number <= raid_disks */
201         if ((layout[0] !=  'n' && layout[0] != 'f' && layout[0] != 'o') ||
202             (copies = strtoul(layout+1, &cp, 10)) < 1 ||
203             copies > 200 ||
204             *cp)
205                 return -1;
206         if (layout[0] == 'n')
207                 rv = 256 + copies;
208         else if (layout[0] == 'o')
209                 rv = 0x10000 + (copies<<8) + 1;
210         else
211                 rv = 1 + (copies<<8);
212         return rv;
213 }
214
215 int parse_layout_faulty(char *layout)
216 {
217         /* Parse the layout string for 'faulty' */
218         int ln = strcspn(layout, "0123456789");
219         char *m = strdup(layout);
220         int mode;
221         m[ln] = 0;
222         mode = map_name(faultylayout, m);
223         if (mode == UnSet)
224                 return -1;
225
226         return mode | (atoi(layout+ln)<< ModeShift);
227 }
228 #endif
229
230 void remove_partitions(int fd)
231 {
232         /* remove partitions from this block devices.
233          * This is used for components added to an array
234          */
235 #ifdef BLKPG_DEL_PARTITION
236         struct blkpg_ioctl_arg a;
237         struct blkpg_partition p;
238
239         a.op = BLKPG_DEL_PARTITION;
240         a.data = (void*)&p;
241         a.datalen = sizeof(p);
242         a.flags = 0;
243         memset(a.data, 0, a.datalen);
244         for (p.pno=0; p.pno < 16; p.pno++)
245                 ioctl(fd, BLKPG, &a);
246 #endif
247 }
248
249 int test_partition(int fd)
250 {
251         /* Check if fd is a whole-disk or a partition.
252          * BLKPG will return EINVAL on a partition, and BLKPG_DEL_PARTITION
253          * will return ENXIO on an invalid partition number.
254          */
255         struct blkpg_ioctl_arg a;
256         struct blkpg_partition p;
257         a.op = BLKPG_DEL_PARTITION;
258         a.data = (void*)&p;
259         a.datalen = sizeof(p);
260         a.flags = 0;
261         memset(a.data, 0, a.datalen);
262         p.pno = 1<<30;
263         if (ioctl(fd, BLKPG, &a) == 0)
264                 /* Very unlikely, but not a partition */
265                 return 0;
266         if (errno == ENXIO)
267                 /* not a partition */
268                 return 0;
269
270         return 1;
271 }
272
273
274 int enough(int level, int raid_disks, int layout, int clean,
275            char *avail, int avail_disks)
276 {
277         int copies, first;
278         switch (level) {
279         case 10:
280                 /* This is the tricky one - we need to check
281                  * which actual disks are present.
282                  */
283                 copies = (layout&255)* ((layout>>8) & 255);
284                 first=0;
285                 do {
286                         /* there must be one of the 'copies' form 'first' */
287                         int n = copies;
288                         int cnt=0;
289                         while (n--) {
290                                 if (avail[first])
291                                         cnt++;
292                                 first = (first+1) % raid_disks;
293                         }
294                         if (cnt == 0)
295                                 return 0;
296
297                 } while (first != 0);
298                 return 1;
299
300         case LEVEL_MULTIPATH:
301                 return avail_disks>= 1;
302         case LEVEL_LINEAR:
303         case 0:
304                 return avail_disks == raid_disks;
305         case 1:
306                 return avail_disks >= 1;
307         case 4:
308         case 5:
309                 if (clean)
310                         return avail_disks >= raid_disks-1;
311                 else
312                         return avail_disks >= raid_disks;
313         case 6:
314                 if (clean)
315                         return avail_disks >= raid_disks-2;
316                 else
317                         return avail_disks >= raid_disks;
318         default:
319                 return 0;
320         }
321 }
322
323 int enough_fd(int fd)
324 {
325         struct mdu_array_info_s array;
326         struct mdu_disk_info_s disk;
327         int avail_disks = 0;
328         int i;
329         char *avail;
330
331         if (ioctl(fd, GET_ARRAY_INFO, &array) != 0 ||
332             array.raid_disks <= 0)
333                 return 0;
334         avail = calloc(array.raid_disks, 1);
335         for (i=0; i<array.raid_disks + array.nr_disks; i++) {
336                 disk.number = i;
337                 if (ioctl(fd, GET_DISK_INFO, &disk) != 0)
338                         continue;
339                 if (! (disk.state & (1<<MD_DISK_SYNC)))
340                         continue;
341                 if (disk.raid_disk < 0 || disk.raid_disk >= array.raid_disks)
342                         continue;
343                 avail_disks++;
344                 avail[disk.raid_disk] = 1;
345         }
346         /* This is used on an active array, so assume it is clean */
347         return enough(array.level, array.raid_disks, array.layout,
348                       1,
349                       avail, avail_disks);
350 }
351
352
353 const int uuid_match_any[4] = { ~0, ~0, ~0, ~0 };
354 int same_uuid(int a[4], int b[4], int swapuuid)
355 {
356         if (memcmp(a, uuid_match_any, sizeof(int[4])) == 0 ||
357             memcmp(b, uuid_match_any, sizeof(int[4])) == 0)
358                 return 1;
359
360         if (swapuuid) {
361                 /* parse uuids are hostendian.
362                  * uuid's from some superblocks are big-ending
363                  * if there is a difference, we need to swap..
364                  */
365                 unsigned char *ac = (unsigned char *)a;
366                 unsigned char *bc = (unsigned char *)b;
367                 int i;
368                 for (i=0; i<16; i+= 4) {
369                         if (ac[i+0] != bc[i+3] ||
370                             ac[i+1] != bc[i+2] ||
371                             ac[i+2] != bc[i+1] ||
372                             ac[i+3] != bc[i+0])
373                                 return 0;
374                 }
375                 return 1;
376         } else {
377                 if (a[0]==b[0] &&
378                     a[1]==b[1] &&
379                     a[2]==b[2] &&
380                     a[3]==b[3])
381                         return 1;
382                 return 0;
383         }
384 }
385 void copy_uuid(void *a, int b[4], int swapuuid)
386 {
387         if (swapuuid) {
388                 /* parse uuids are hostendian.
389                  * uuid's from some superblocks are big-ending
390                  * if there is a difference, we need to swap..
391                  */
392                 unsigned char *ac = (unsigned char *)a;
393                 unsigned char *bc = (unsigned char *)b;
394                 int i;
395                 for (i=0; i<16; i+= 4) {
396                         ac[i+0] = bc[i+3];
397                         ac[i+1] = bc[i+2];
398                         ac[i+2] = bc[i+1];
399                         ac[i+3] = bc[i+0];
400                 }
401         } else
402                 memcpy(a, b, 16);
403 }
404
405 char *__fname_from_uuid(int id[4], int swap, char *buf, char sep)
406 {
407         int i, j;
408         char uuid[16];
409         char *c = buf;
410         strcpy(c, "UUID-");
411         c += strlen(c);
412         copy_uuid(uuid, id, swap);
413         for (i = 0; i < 4; i++) {
414                 if (i)
415                         *c++ = sep;
416                 for (j = 3; j >= 0; j--) {
417                         sprintf(c,"%02x", (unsigned char) uuid[j+4*i]);
418                         c+= 2;
419                 }
420         }
421         return buf;
422
423 }
424
425 char *fname_from_uuid(struct supertype *st, struct mdinfo *info, char *buf, char sep)
426 {
427         // dirty hack to work around an issue with super1 superblocks...
428         // super1 superblocks need swapuuid set in order for assembly to
429         // work, but can't have it set if we want this printout to match
430         // all the other uuid printouts in super1.c, so we force swapuuid
431         // to 1 to make our printout match the rest of super1
432         return __fname_from_uuid(info->uuid, (st->ss == &super1) ? 1 : st->ss->swapuuid, buf, sep);
433 }
434
435 #ifndef MDASSEMBLE
436 int check_ext2(int fd, char *name)
437 {
438         /*
439          * Check for an ext2fs file system.
440          * Superblock is always 1K at 1K offset
441          *
442          * s_magic is le16 at 56 == 0xEF53
443          * report mtime - le32 at 44
444          * blocks - le32 at 4
445          * logblksize - le32 at 24
446          */
447         unsigned char sb[1024];
448         time_t mtime;
449         int size, bsize;
450         if (lseek(fd, 1024,0)!= 1024)
451                 return 0;
452         if (read(fd, sb, 1024)!= 1024)
453                 return 0;
454         if (sb[56] != 0x53 || sb[57] != 0xef)
455                 return 0;
456
457         mtime = sb[44]|(sb[45]|(sb[46]|sb[47]<<8)<<8)<<8;
458         bsize = sb[24]|(sb[25]|(sb[26]|sb[27]<<8)<<8)<<8;
459         size = sb[4]|(sb[5]|(sb[6]|sb[7]<<8)<<8)<<8;
460         fprintf(stderr, Name ": %s appears to contain an ext2fs file system\n",
461                 name);
462         fprintf(stderr,"    size=%dK  mtime=%s",
463                 size*(1<<bsize), ctime(&mtime));
464         return 1;
465 }
466
467 int check_reiser(int fd, char *name)
468 {
469         /*
470          * superblock is at 64K
471          * size is 1024;
472          * Magic string "ReIsErFs" or "ReIsEr2Fs" at 52
473          *
474          */
475         unsigned char sb[1024];
476         unsigned long size;
477         if (lseek(fd, 64*1024, 0) != 64*1024)
478                 return 0;
479         if (read(fd, sb, 1024) != 1024)
480                 return 0;
481         if (strncmp((char*)sb+52, "ReIsErFs",8)!=0 &&
482             strncmp((char*)sb+52, "ReIsEr2Fs",9)!=0)
483                 return 0;
484         fprintf(stderr, Name ": %s appears to contain a reiserfs file system\n",name);
485         size = sb[0]|(sb[1]|(sb[2]|sb[3]<<8)<<8)<<8;
486         fprintf(stderr, "    size = %luK\n", size*4);
487
488         return 1;
489 }
490
491 int check_raid(int fd, char *name)
492 {
493         struct mdinfo info;
494         time_t crtime;
495         char *level;
496         struct supertype *st = guess_super(fd);
497
498         if (!st) return 0;
499         st->ss->load_super(st, fd, name);
500         /* Looks like a raid array .. */
501         fprintf(stderr, Name ": %s appears to be part of a raid array:\n",
502                 name);
503         st->ss->getinfo_super(st, &info, NULL);
504         st->ss->free_super(st);
505         crtime = info.array.ctime;
506         level = map_num(pers, info.array.level);
507         if (!level) level = "-unknown-";
508         fprintf(stderr, "    level=%s devices=%d ctime=%s",
509                 level, info.array.raid_disks, ctime(&crtime));
510         return 1;
511 }
512
513 int ask(char *mesg)
514 {
515         char *add = "";
516         int i;
517         for (i=0; i<5; i++) {
518                 char buf[100];
519                 fprintf(stderr, "%s%s", mesg, add);
520                 fflush(stderr);
521                 if (fgets(buf, 100, stdin)==NULL)
522                         return 0;
523                 if (buf[0]=='y' || buf[0]=='Y')
524                         return 1;
525                 if (buf[0]=='n' || buf[0]=='N')
526                         return 0;
527                 add = "(y/n) ";
528         }
529         fprintf(stderr, Name ": assuming 'no'\n");
530         return 0;
531 }
532 #endif /* MDASSEMBLE */
533
534 char *map_num(mapping_t *map, int num)
535 {
536         while (map->name) {
537                 if (map->num == num)
538                         return map->name;
539                 map++;
540         }
541         return NULL;
542 }
543
544 int map_name(mapping_t *map, char *name)
545 {
546         while (map->name) {
547                 if (strcmp(map->name, name)==0)
548                         return map->num;
549                 map++;
550         }
551         return UnSet;
552 }
553
554
555 int is_standard(char *dev, int *nump)
556 {
557         /* tests if dev is a "standard" md dev name.
558          * i.e if the last component is "/dNN" or "/mdNN",
559          * where NN is a string of digits
560          * Returns 1 if a partitionable standard,
561          *   -1 if non-partitonable,
562          *   0 if not a standard name.
563          */
564         char *d = strrchr(dev, '/');
565         int type=0;
566         int num;
567         if (!d)
568                 return 0;
569         if (strncmp(d, "/d",2)==0)
570                 d += 2, type=1; /* /dev/md/dN{pM} */
571         else if (strncmp(d, "/md_d", 5)==0)
572                 d += 5, type=1; /* /dev/md_dN{pM} */
573         else if (strncmp(d, "/md", 3)==0)
574                 d += 3, type=-1; /* /dev/mdN */
575         else if (d-dev > 3 && strncmp(d-2, "md/", 3)==0)
576                 d += 1, type=-1; /* /dev/md/N */
577         else
578                 return 0;
579         if (!*d)
580                 return 0;
581         num = atoi(d);
582         while (isdigit(*d))
583                 d++;
584         if (*d)
585                 return 0;
586         if (nump) *nump = num;
587
588         return type;
589 }
590
591
592 /*
593  * convert a major/minor pair for a block device into a name in /dev, if possible.
594  * On the first call, walk /dev collecting name.
595  * Put them in a simple linked listfor now.
596  */
597 struct devmap {
598     int major, minor;
599     char *name;
600     struct devmap *next;
601 } *devlist = NULL;
602 int devlist_ready = 0;
603
604 int add_dev(const char *name, const struct stat *stb, int flag, struct FTW *s)
605 {
606         struct stat st;
607
608         if (S_ISLNK(stb->st_mode)) {
609                 if (stat(name, &st) != 0)
610                         return 0;
611                 stb = &st;
612         }
613
614         if ((stb->st_mode&S_IFMT)== S_IFBLK) {
615                 char *n = strdup(name);
616                 struct devmap *dm = malloc(sizeof(*dm));
617                 if (strncmp(n, "/dev/./", 7)==0)
618                         strcpy(n+4, name+6);
619                 if (dm) {
620                         dm->major = major(stb->st_rdev);
621                         dm->minor = minor(stb->st_rdev);
622                         dm->name = n;
623                         dm->next = devlist;
624                         devlist = dm;
625                 }
626         }
627         return 0;
628 }
629
630 #ifndef HAVE_NFTW
631 #ifdef HAVE_FTW
632 int add_dev_1(const char *name, const struct stat *stb, int flag)
633 {
634         return add_dev(name, stb, flag, NULL);
635 }
636 int nftw(const char *path, int (*han)(const char *name, const struct stat *stb, int flag, struct FTW *s), int nopenfd, int flags)
637 {
638         return ftw(path, add_dev_1, nopenfd);
639 }
640 #else
641 int nftw(const char *path, int (*han)(const char *name, const struct stat *stb, int flag, struct FTW *s), int nopenfd, int flags)
642 {
643         return 0;
644 }
645 #endif /* HAVE_FTW */
646 #endif /* HAVE_NFTW */
647
648 /*
649  * Find a block device with the right major/minor number.
650  * If we find multiple names, choose the shortest.
651  * If we find a name in /dev/md/, we prefer that.
652  * This applies only to names for MD devices.
653  */
654 char *map_dev(int major, int minor, int create)
655 {
656         struct devmap *p;
657         char *regular = NULL, *preferred=NULL;
658         int did_check = 0;
659
660         if (major == 0 && minor == 0)
661                         return NULL;
662
663  retry:
664         if (!devlist_ready) {
665                 char *dev = "/dev";
666                 struct stat stb;
667                 while(devlist) {
668                         struct devmap *d = devlist;
669                         devlist = d->next;
670                         free(d->name);
671                         free(d);
672                 }
673                 if (lstat(dev, &stb)==0 &&
674                     S_ISLNK(stb.st_mode))
675                         dev = "/dev/.";
676                 nftw(dev, add_dev, 10, FTW_PHYS);
677                 devlist_ready=1;
678                 did_check = 1;
679         }
680
681         for (p=devlist; p; p=p->next)
682                 if (p->major == major &&
683                     p->minor == minor) {
684                         if (strncmp(p->name, "/dev/md/",8) == 0) {
685                                 if (preferred == NULL ||
686                                     strlen(p->name) < strlen(preferred))
687                                         preferred = p->name;
688                         } else {
689                                 if (regular == NULL ||
690                                     strlen(p->name) < strlen(regular))
691                                         regular = p->name;
692                         }
693                 }
694         if (!regular && !preferred && !did_check) {
695                 devlist_ready = 0;
696                 goto retry;
697         }
698         if (create && !regular && !preferred) {
699                 static char buf[30];
700                 snprintf(buf, sizeof(buf), "%d:%d", major, minor);
701                 regular = buf;
702         }
703
704         return preferred ? preferred : regular;
705 }
706
707 unsigned long calc_csum(void *super, int bytes)
708 {
709         unsigned long long newcsum = 0;
710         int i;
711         unsigned int csum;
712         unsigned int *superc = (unsigned int*) super;
713
714         for(i=0; i<bytes/4; i++)
715                 newcsum+= superc[i];
716         csum = (newcsum& 0xffffffff) + (newcsum>>32);
717 #ifdef __alpha__
718 /* The in-kernel checksum calculation is always 16bit on
719  * the alpha, though it is 32 bit on i386...
720  * I wonder what it is elsewhere... (it uses and API in
721  * a way that it shouldn't).
722  */
723         csum = (csum & 0xffff) + (csum >> 16);
724         csum = (csum & 0xffff) + (csum >> 16);
725 #endif
726         return csum;
727 }
728
729 #ifndef MDASSEMBLE
730 char *human_size(long long bytes)
731 {
732         static char buf[30];
733
734         /* We convert bytes to either centi-M{ega,ibi}bytes or
735          * centi-G{igi,ibi}bytes, with appropriate rounding,
736          * and then print 1/100th of those as a decimal.
737          * We allow upto 2048Megabytes before converting to
738          * gigabytes, as that shows more precision and isn't
739          * too large a number.
740          * Terrabytes are not yet handled.
741          */
742
743         if (bytes < 5000*1024)
744                 buf[0]=0;
745         else if (bytes < 2*1024LL*1024LL*1024LL) {
746                 long cMiB = (bytes / ( (1LL<<20) / 200LL ) +1) /2;
747                 long cMB  = (bytes / ( 1000000LL / 200LL ) +1) /2;
748                 snprintf(buf, sizeof(buf), " (%ld.%02ld MiB %ld.%02ld MB)",
749                         cMiB/100 , cMiB % 100,
750                         cMB/100, cMB % 100);
751         } else {
752                 long cGiB = (bytes / ( (1LL<<30) / 200LL ) +1) /2;
753                 long cGB  = (bytes / (1000000000LL/200LL ) +1) /2;
754                 snprintf(buf, sizeof(buf), " (%ld.%02ld GiB %ld.%02ld GB)",
755                         cGiB/100 , cGiB % 100,
756                         cGB/100, cGB % 100);
757         }
758         return buf;
759 }
760
761 char *human_size_brief(long long bytes)
762 {
763         static char buf[30];
764
765         if (bytes < 5000*1024)
766                 snprintf(buf, sizeof(buf), "%ld.%02ldKiB",
767                         (long)(bytes>>10), (long)(((bytes&1023)*100+512)/1024)
768                         );
769         else if (bytes < 2*1024LL*1024LL*1024LL)
770                 snprintf(buf, sizeof(buf), "%ld.%02ldMiB",
771                         (long)(bytes>>20),
772                         (long)((bytes&0xfffff)+0x100000/200)/(0x100000/100)
773                         );
774         else
775                 snprintf(buf, sizeof(buf), "%ld.%02ldGiB",
776                         (long)(bytes>>30),
777                         (long)(((bytes>>10)&0xfffff)+0x100000/200)/(0x100000/100)
778                         );
779         return buf;
780 }
781
782 void print_r10_layout(int layout)
783 {
784         int near = layout & 255;
785         int far = (layout >> 8) & 255;
786         int offset = (layout&0x10000);
787         char *sep = "";
788
789         if (near != 1) {
790                 printf("%s near=%d", sep, near);
791                 sep = ",";
792         }
793         if (far != 1)
794                 printf("%s %s=%d", sep, offset?"offset":"far", far);
795         if (near*far == 1)
796                 printf("NO REDUNDANCY");
797 }
798 #endif
799
800 unsigned long long calc_array_size(int level, int raid_disks, int layout,
801                                    int chunksize, unsigned long long devsize)
802 {
803         int data_disks = 0;
804         switch (level) {
805         case 0: data_disks = raid_disks; break;
806         case 1: data_disks = 1; break;
807         case 4:
808         case 5: data_disks = raid_disks - 1; break;
809         case 6: data_disks = raid_disks - 2; break;
810         case 10: data_disks = raid_disks / (layout & 255) / ((layout>>8)&255);
811                 break;
812         }
813         devsize &= ~(unsigned long long)((chunksize>>9)-1);
814         return data_disks * devsize;
815 }
816
817 int get_mdp_major(void)
818 {
819 static int mdp_major = -1;
820         FILE *fl;
821         char *w;
822         int have_block = 0;
823         int have_devices = 0;
824         int last_num = -1;
825
826         if (mdp_major != -1)
827                 return mdp_major;
828         fl = fopen("/proc/devices", "r");
829         if (!fl)
830                 return -1;
831         while ((w = conf_word(fl, 1))) {
832                 if (have_block && strcmp(w, "devices:")==0)
833                         have_devices = 1;
834                 have_block =  (strcmp(w, "Block")==0);
835                 if (isdigit(w[0]))
836                         last_num = atoi(w);
837                 if (have_devices && strcmp(w, "mdp")==0)
838                         mdp_major = last_num;
839                 free(w);
840         }
841         fclose(fl);
842         return mdp_major;
843 }
844
845 #if !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO)
846 char *get_md_name(int dev)
847 {
848         /* find /dev/md%d or /dev/md/%d or make a device /dev/.tmp.md%d */
849         /* if dev < 0, want /dev/md/d%d or find mdp in /proc/devices ... */
850         static char devname[50];
851         struct stat stb;
852         dev_t rdev;
853         char *dn;
854
855         if (dev < 0) {
856                 int mdp =  get_mdp_major();
857                 if (mdp < 0) return NULL;
858                 rdev = makedev(mdp, (-1-dev)<<6);
859                 snprintf(devname, sizeof(devname), "/dev/md/d%d", -1-dev);
860                 if (stat(devname, &stb) == 0
861                     && (S_IFMT&stb.st_mode) == S_IFBLK
862                     && (stb.st_rdev == rdev))
863                         return devname;
864         } else {
865                 rdev = makedev(MD_MAJOR, dev);
866                 snprintf(devname, sizeof(devname), "/dev/md%d", dev);
867                 if (stat(devname, &stb) == 0
868                     && (S_IFMT&stb.st_mode) == S_IFBLK
869                     && (stb.st_rdev == rdev))
870                         return devname;
871
872                 snprintf(devname, sizeof(devname), "/dev/md/%d", dev);
873                 if (stat(devname, &stb) == 0
874                     && (S_IFMT&stb.st_mode) == S_IFBLK
875                     && (stb.st_rdev == rdev))
876                         return devname;
877         }
878         dn = map_dev(major(rdev), minor(rdev), 0);
879         if (dn)
880                 return dn;
881         snprintf(devname, sizeof(devname), "/dev/.tmp.md%d", dev);
882         if (mknod(devname, S_IFBLK | 0600, rdev) == -1)
883                 if (errno != EEXIST)
884                         return NULL;
885
886         if (stat(devname, &stb) == 0
887             && (S_IFMT&stb.st_mode) == S_IFBLK
888             && (stb.st_rdev == rdev))
889                 return devname;
890         unlink(devname);
891         return NULL;
892 }
893
894 void put_md_name(char *name)
895 {
896         if (strncmp(name, "/dev/.tmp.md", 12)==0)
897                 unlink(name);
898 }
899
900 int find_free_devnum(int use_partitions)
901 {
902         int devnum;
903         for (devnum = 127; devnum != 128;
904              devnum = devnum ? devnum-1 : (1<<20)-1) {
905                 char *dn;
906                 int _devnum;
907
908                 _devnum = use_partitions ? (-1-devnum) : devnum;
909                 if (mddev_busy(_devnum))
910                         continue;
911                 /* make sure it is new to /dev too, at least as a
912                  * non-standard */
913                 dn = map_dev(dev2major(_devnum), dev2minor(_devnum), 0);
914                 if (dn && ! is_standard(dn, NULL))
915                         continue;
916                 break;
917         }
918         if (devnum == 128)
919                 return NoMdDev;
920         return use_partitions ? (-1-devnum) : devnum;
921 }
922 #endif /* !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO) */
923
924 int dev_open(char *dev, int flags)
925 {
926         /* like 'open', but if 'dev' matches %d:%d, create a temp
927          * block device and open that
928          */
929         char *e;
930         int fd = -1;
931         char devname[32];
932         int major;
933         int minor;
934
935         if (!dev) return -1;
936         flags |= O_DIRECT;
937
938         major = strtoul(dev, &e, 0);
939         if (e > dev && *e == ':' && e[1] &&
940             (minor = strtoul(e+1, &e, 0)) >= 0 &&
941             *e == 0) {
942                 char *path = map_dev(major, minor, 0);
943                 if (path)
944                         fd = open(path, flags);
945                 if (fd < 0) {
946                         snprintf(devname, sizeof(devname), "/dev/.tmp.md.%d:%d:%d",
947                                  (int)getpid(), major, minor);
948                         if (mknod(devname, S_IFBLK|0600, makedev(major, minor))==0) {
949                                 fd = open(devname, flags);
950                                 unlink(devname);
951                         }
952                 }
953                 if (fd < 0) {
954                         snprintf(devname, sizeof(devname), "/tmp/.tmp.md.%d:%d:%d",
955                                  (int)getpid(), major, minor);
956                         if (mknod(devname, S_IFBLK|0600, makedev(major, minor))==0) {
957                                 fd = open(devname, flags);
958                                 unlink(devname);
959                         }
960                 }
961         } else
962                 fd = open(dev, flags);
963         return fd;
964 }
965
966 int open_dev(int devnum)
967 {
968         char buf[20];
969
970         sprintf(buf, "%d:%d", dev2major(devnum), dev2minor(devnum));
971         return dev_open(buf, O_RDWR);
972 }
973
974 int open_dev_excl(int devnum)
975 {
976         char buf[20];
977         int i;
978
979         sprintf(buf, "%d:%d", dev2major(devnum), dev2minor(devnum));
980         for (i=0 ; i<25 ; i++) {
981                 int fd = dev_open(buf, O_RDWR|O_EXCL);
982                 if (fd >= 0)
983                         return fd;
984                 if (errno != EBUSY)
985                         return fd;
986                 usleep(200000);
987         }
988         return -1;
989 }
990
991 int same_dev(char *one, char *two)
992 {
993         struct stat st1, st2;
994         if (stat(one, &st1) != 0)
995                 return 0;
996         if (stat(two, &st2) != 0)
997                 return 0;
998         if ((st1.st_mode & S_IFMT) != S_IFBLK)
999                 return 0;
1000         if ((st2.st_mode & S_IFMT) != S_IFBLK)
1001                 return 0;
1002         return st1.st_rdev == st2.st_rdev;
1003 }
1004
1005 void wait_for(char *dev, int fd)
1006 {
1007         int i;
1008         struct stat stb_want;
1009
1010         if (fstat(fd, &stb_want) != 0 ||
1011             (stb_want.st_mode & S_IFMT) != S_IFBLK)
1012                 return;
1013
1014         for (i=0 ; i<25 ; i++) {
1015                 struct stat stb;
1016                 if (stat(dev, &stb) == 0 &&
1017                     (stb.st_mode & S_IFMT) == S_IFBLK &&
1018                     (stb.st_rdev == stb_want.st_rdev))
1019                         return;
1020                 usleep(200000);
1021         }
1022         if (i == 25)
1023                 dprintf("%s: timeout waiting for %s\n", __func__, dev);
1024 }
1025
1026 struct superswitch *superlist[] =
1027 {
1028         &super0, &super1,
1029         &super_ddf, &super_imsm,
1030         &mbr, &gpt,
1031         NULL };
1032
1033 #if !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO)
1034
1035 struct supertype *super_by_fd(int fd, char **subarrayp)
1036 {
1037         mdu_array_info_t array;
1038         int vers;
1039         int minor;
1040         struct supertype *st = NULL;
1041         struct mdinfo *sra;
1042         char *verstr;
1043         char version[20];
1044         int i;
1045         char *subarray = NULL;
1046
1047         sra = sysfs_read(fd, 0, GET_VERSION);
1048
1049         if (sra) {
1050                 vers = sra->array.major_version;
1051                 minor = sra->array.minor_version;
1052                 verstr = sra->text_version;
1053         } else {
1054                 if (ioctl(fd, GET_ARRAY_INFO, &array))
1055                         array.major_version = array.minor_version = 0;
1056                 vers = array.major_version;
1057                 minor = array.minor_version;
1058                 verstr = "";
1059         }
1060
1061         if (vers != -1) {
1062                 sprintf(version, "%d.%d", vers, minor);
1063                 verstr = version;
1064         }
1065         if (minor == -2 && is_subarray(verstr)) {
1066                 char *dev = verstr+1;
1067                 subarray = strchr(dev, '/');
1068                 int devnum;
1069                 if (subarray)
1070                         *subarray++ = '\0';
1071                 devnum = devname2devnum(dev);
1072                 subarray = strdup(subarray);
1073                 if (sra)
1074                         sysfs_free(sra);
1075                 sra = sysfs_read(-1, devnum, GET_VERSION);
1076                 if (sra && sra->text_version[0])
1077                         verstr = sra->text_version;
1078                 else
1079                         verstr = "-no-metadata-";
1080         }
1081
1082         for (i = 0; st == NULL && superlist[i] ; i++)
1083                 st = superlist[i]->match_metadata_desc(verstr);
1084
1085         if (sra)
1086                 sysfs_free(sra);
1087         if (st) {
1088                 st->sb = NULL;
1089                 st->subarray[0] = 0;
1090                 *subarrayp = subarray;
1091         } else
1092                 free(subarray);
1093         return st;
1094 }
1095 #endif /* !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO) */
1096
1097
1098 struct supertype *dup_super(struct supertype *orig)
1099 {
1100         struct supertype *st;
1101
1102         if (!orig)
1103                 return orig;
1104         st = malloc(sizeof(*st));
1105         if (!st)
1106                 return st;
1107         memset(st, 0, sizeof(*st));
1108         st->ss = orig->ss;
1109         st->max_devs = orig->max_devs;
1110         st->minor_version = orig->minor_version;
1111         strcpy(st->subarray, orig->subarray);
1112         st->sb = NULL;
1113         st->info = NULL;
1114         return st;
1115 }
1116
1117 struct supertype *guess_super_type(int fd, enum guess_types guess_type)
1118 {
1119         /* try each load_super to find the best match,
1120          * and return the best superswitch
1121          */
1122         struct superswitch  *ss;
1123         struct supertype *st;
1124         time_t besttime = 0;
1125         int bestsuper = -1;
1126         int i;
1127
1128         st = malloc(sizeof(*st));
1129         for (i=0 ; superlist[i]; i++) {
1130                 int rv;
1131                 ss = superlist[i];
1132                 if (guess_type == guess_array && ss->add_to_super == NULL)
1133                         continue;
1134                 if (guess_type == guess_partitions && ss->add_to_super != NULL)
1135                         continue;
1136                 memset(st, 0, sizeof(*st));
1137                 rv = ss->load_super(st, fd, NULL);
1138                 if (rv == 0) {
1139                         struct mdinfo info;
1140                         st->ss->getinfo_super(st, &info, NULL);
1141                         if (bestsuper == -1 ||
1142                             besttime < info.array.ctime) {
1143                                 bestsuper = i;
1144                                 besttime = info.array.ctime;
1145                         }
1146                         ss->free_super(st);
1147                 }
1148         }
1149         if (bestsuper != -1) {
1150                 int rv;
1151                 memset(st, 0, sizeof(*st));
1152                 rv = superlist[bestsuper]->load_super(st, fd, NULL);
1153                 if (rv == 0) {
1154                         superlist[bestsuper]->free_super(st);
1155                         return st;
1156                 }
1157         }
1158         free(st);
1159         return NULL;
1160 }
1161
1162 /* Return size of device in bytes */
1163 int get_dev_size(int fd, char *dname, unsigned long long *sizep)
1164 {
1165         unsigned long long ldsize;
1166         struct stat st;
1167
1168         if (fstat(fd, &st) != -1 && S_ISREG(st.st_mode))
1169                 ldsize = (unsigned long long)st.st_size;
1170         else
1171 #ifdef BLKGETSIZE64
1172         if (ioctl(fd, BLKGETSIZE64, &ldsize) != 0)
1173 #endif
1174         {
1175                 unsigned long dsize;
1176                 if (ioctl(fd, BLKGETSIZE, &dsize) == 0) {
1177                         ldsize = dsize;
1178                         ldsize <<= 9;
1179                 } else {
1180                         if (dname)
1181                                 fprintf(stderr, Name ": Cannot get size of %s: %s\b",
1182                                         dname, strerror(errno));
1183                         return 0;
1184                 }
1185         }
1186         *sizep = ldsize;
1187         return 1;
1188 }
1189
1190
1191 /* Sets endofpart parameter to the last block used by the last GPT partition on the device.
1192  * Returns: 1 if successful
1193  *         -1 for unknown partition type
1194  *          0 for other errors
1195  */
1196 static int get_gpt_last_partition_end(int fd, unsigned long long *endofpart)
1197 {
1198         struct GPT gpt;
1199         unsigned char buf[512];
1200         unsigned char empty_gpt_entry[16]= {0};
1201         struct GPT_part_entry *part;
1202         unsigned long long curr_part_end;
1203         unsigned all_partitions, entry_size;
1204         unsigned part_nr;
1205
1206         *endofpart = 0;
1207
1208         BUILD_BUG_ON(sizeof(gpt) != 512);
1209         /* read GPT header */
1210         lseek(fd, 512, SEEK_SET);
1211         if (read(fd, &gpt, 512) != 512)
1212                 return 0;
1213
1214         /* get the number of partition entries and the entry size */
1215         all_partitions = __le32_to_cpu(gpt.part_cnt);
1216         entry_size = __le32_to_cpu(gpt.part_size);
1217
1218         /* Check GPT signature*/
1219         if (gpt.magic != GPT_SIGNATURE_MAGIC)
1220                 return -1;
1221
1222         /* sanity checks */
1223         if (all_partitions > 1024 ||
1224             entry_size > 512)
1225                 return -1;
1226
1227         /* read first GPT partition entries */
1228         if (read(fd, buf, 512) != 512)
1229                 return 0;
1230
1231         part = (struct GPT_part_entry*)buf;
1232
1233         for (part_nr=0; part_nr < all_partitions; part_nr++) {
1234                 /* is this valid partition? */
1235                 if (memcmp(part->type_guid, empty_gpt_entry, 16) != 0) {
1236                         /* check the last lba for the current partition */
1237                         curr_part_end = __le64_to_cpu(part->ending_lba);
1238                         if (curr_part_end > *endofpart)
1239                                 *endofpart = curr_part_end;
1240                 }
1241
1242                 part = (struct GPT_part_entry*)((unsigned char*)part + entry_size);
1243
1244                 if ((unsigned char *)part >= buf + 512) {
1245                         if (read(fd, buf, 512) != 512)
1246                                 return 0;
1247                         part = (struct GPT_part_entry*)buf;
1248                 }
1249         }
1250         return 1;
1251 }
1252
1253 /* Sets endofpart parameter to the last block used by the last partition on the device.
1254  * Returns: 1 if successful
1255  *         -1 for unknown partition type
1256  *          0 for other errors
1257  */
1258 static int get_last_partition_end(int fd, unsigned long long *endofpart)
1259 {
1260         struct MBR boot_sect;
1261         struct MBR_part_record *part;
1262         unsigned long long curr_part_end;
1263         unsigned part_nr;
1264         int retval = 0;
1265
1266         *endofpart = 0;
1267
1268         BUILD_BUG_ON(sizeof(boot_sect) != 512);
1269         /* read MBR */
1270         lseek(fd, 0, 0);
1271         if (read(fd, &boot_sect, 512) != 512)
1272                 goto abort;
1273
1274         /* check MBP signature */
1275         if (boot_sect.magic == MBR_SIGNATURE_MAGIC) {
1276                 retval = 1;
1277                 /* found the correct signature */
1278                 part = boot_sect.parts;
1279
1280                 for (part_nr=0; part_nr < MBR_PARTITIONS; part_nr++) {
1281                         /* check for GPT type */
1282                         if (part->part_type == MBR_GPT_PARTITION_TYPE) {
1283                                 retval = get_gpt_last_partition_end(fd, endofpart);
1284                                 break;
1285                         }
1286                         /* check the last used lba for the current partition  */
1287                         curr_part_end = __le32_to_cpu(part->first_sect_lba) +
1288                                 __le32_to_cpu(part->blocks_num);
1289                         if (curr_part_end > *endofpart)
1290                                 *endofpart = curr_part_end;
1291
1292                         part++;
1293                 }
1294         } else {
1295                 /* Unknown partition table */
1296                 retval = -1;
1297         }
1298  abort:
1299         return retval;
1300 }
1301
1302 int check_partitions(int fd, char *dname, unsigned long long freesize)
1303 {
1304         /*
1305          * Check where the last partition ends
1306          */
1307         unsigned long long endofpart;
1308         int ret;
1309
1310         if ((ret = get_last_partition_end(fd, &endofpart)) > 0) {
1311                 /* There appears to be a partition table here */
1312                 if (freesize == 0) {
1313                         /* partitions will not be visible in new device */
1314                         fprintf(stderr,
1315                                 Name ": partition table exists on %s but will be lost or\n"
1316                                 "       meaningless after creating array\n",
1317                                 dname);
1318                         return 1;
1319                 } else if (endofpart > freesize) {
1320                         /* last partition overlaps metadata */
1321                         fprintf(stderr,
1322                                 Name ": metadata will over-write last partition on %s.\n",
1323                                 dname);
1324                         return 1;
1325                 }
1326         }
1327         return 0;
1328 }
1329
1330 void get_one_disk(int mdfd, mdu_array_info_t *ainf, mdu_disk_info_t *disk)
1331 {
1332         int d;
1333         ioctl(mdfd, GET_ARRAY_INFO, ainf);
1334         for (d = 0 ; d < ainf->raid_disks + ainf->nr_disks ; d++)
1335                 if (ioctl(mdfd, GET_DISK_INFO, disk) == 0)
1336                         return;
1337 }
1338
1339 int open_container(int fd)
1340 {
1341         /* 'fd' is a block device.  Find out if it is in use
1342          * by a container, and return an open fd on that container.
1343          */
1344         char path[256];
1345         char *e;
1346         DIR *dir;
1347         struct dirent *de;
1348         int dfd, n;
1349         char buf[200];
1350         int major, minor;
1351         struct stat st;
1352
1353         if (fstat(fd, &st) != 0)
1354                 return -1;
1355         sprintf(path, "/sys/dev/block/%d:%d/holders",
1356                 (int)major(st.st_rdev), (int)minor(st.st_rdev));
1357         e = path + strlen(path);
1358
1359         dir = opendir(path);
1360         if (!dir)
1361                 return -1;
1362         while ((de = readdir(dir))) {
1363                 if (de->d_ino == 0)
1364                         continue;
1365                 if (de->d_name[0] == '.')
1366                         continue;
1367                 sprintf(e, "/%s/dev", de->d_name);
1368                 dfd = open(path, O_RDONLY);
1369                 if (dfd < 0)
1370                         continue;
1371                 n = read(dfd, buf, sizeof(buf));
1372                 close(dfd);
1373                 if (n <= 0 || (unsigned)n >= sizeof(buf))
1374                         continue;
1375                 buf[n] = 0;
1376                 if (sscanf(buf, "%d:%d", &major, &minor) != 2)
1377                         continue;
1378                 sprintf(buf, "%d:%d", major, minor);
1379                 dfd = dev_open(buf, O_RDONLY);
1380                 if (dfd >= 0) {
1381                         closedir(dir);
1382                         return dfd;
1383                 }
1384         }
1385         closedir(dir);
1386         return -1;
1387 }
1388
1389 struct superswitch *version_to_superswitch(char *vers)
1390 {
1391         int i;
1392
1393         for (i = 0; superlist[i]; i++) {
1394                 struct superswitch *ss = superlist[i];
1395
1396                 if (strcmp(vers, ss->name) == 0)
1397                         return ss;
1398         }
1399
1400         return NULL;
1401 }
1402
1403 int is_container_member(struct mdstat_ent *mdstat, char *container)
1404 {
1405         if (mdstat->metadata_version == NULL ||
1406             strncmp(mdstat->metadata_version, "external:", 9) != 0 ||
1407             !is_subarray(mdstat->metadata_version+9) ||
1408             strncmp(mdstat->metadata_version+10, container, strlen(container)) != 0 ||
1409             mdstat->metadata_version[10+strlen(container)] != '/')
1410                 return 0;
1411
1412         return 1;
1413 }
1414
1415 int is_subarray_active(char *subarray, char *container)
1416 {
1417         struct mdstat_ent *mdstat = mdstat_read(0, 0);
1418         struct mdstat_ent *ent;
1419
1420         for (ent = mdstat; ent; ent = ent->next) {
1421                 if (is_container_member(ent, container)) {
1422                         char *inst = &ent->metadata_version[10+strlen(container)+1];
1423
1424                         if (!subarray || strcmp(inst, subarray) == 0)
1425                                 break;
1426                 }
1427         }
1428
1429         free_mdstat(mdstat);
1430
1431         return ent != NULL;
1432 }
1433
1434 int is_container_active(char *container)
1435 {
1436         return is_subarray_active(NULL, container);
1437 }
1438
1439 /* open_subarray - opens a subarray in a container
1440  * @dev: container device name
1441  * @st: empty supertype
1442  * @quiet: block reporting errors flag
1443  *
1444  * On success returns an fd to a container and fills in *st
1445  */
1446 int open_subarray(char *dev, char *subarray, struct supertype *st, int quiet)
1447 {
1448         struct mdinfo *mdi;
1449         int fd, err = 1;
1450
1451         fd = open(dev, O_RDWR|O_EXCL);
1452         if (fd < 0) {
1453                 if (!quiet)
1454                         fprintf(stderr, Name ": Couldn't open %s, aborting\n",
1455                                 dev);
1456                 return 2;
1457         }
1458
1459         st->devnum = fd2devnum(fd);
1460         if (st->devnum == NoMdDev) {
1461                 if (!quiet)
1462                         fprintf(stderr,
1463                                 Name ": Failed to determine device number for %s\n",
1464                                 dev);
1465                 goto close_fd;
1466         }
1467
1468         mdi = sysfs_read(fd, st->devnum, GET_VERSION|GET_LEVEL);
1469         if (!mdi) {
1470                 if (!quiet)
1471                         fprintf(stderr, Name ": Failed to read sysfs for %s\n",
1472                                 dev);
1473                 goto close_fd;
1474         }
1475
1476         if (mdi->array.level != UnSet) {
1477                 if (!quiet)
1478                         fprintf(stderr, Name ": %s is not a container\n", dev);
1479                 goto free_sysfs;
1480         }
1481
1482         st->ss = version_to_superswitch(mdi->text_version);
1483         if (!st->ss) {
1484                 if (!quiet)
1485                         fprintf(stderr,
1486                                 Name ": Operation not supported for %s metadata\n",
1487                                 mdi->text_version);
1488                 goto free_sysfs;
1489         }
1490
1491         st->devname = devnum2devname(st->devnum);
1492         if (!st->devname) {
1493                 if (!quiet)
1494                         fprintf(stderr, Name ": Failed to allocate device name\n");
1495                 goto free_sysfs;
1496         }
1497
1498         strncpy(st->subarray, subarray, sizeof(st->subarray)-1);
1499
1500         if (st->ss->load_super(st, fd, NULL)) {
1501                 if (!quiet)
1502                         fprintf(stderr, Name ": Failed to find subarray-%s in %s\n",
1503                                 st->subarray, dev);
1504                 goto free_name;
1505         }
1506
1507         if (!st->loaded_container) {
1508                 if (!quiet)
1509                         fprintf(stderr, Name ": %s is not a container\n", dev);
1510                 goto free_super;
1511         }
1512
1513         err = 0;
1514
1515  free_super:
1516         if (err)
1517                 st->ss->free_super(st);
1518  free_name:
1519         if (err)
1520                 free(st->devname);
1521  free_sysfs:
1522         sysfs_free(mdi);
1523  close_fd:
1524         if (err)
1525                 close(fd);
1526
1527         if (err)
1528                 return -1;
1529         else
1530                 return fd;
1531 }
1532
1533 int add_disk(int mdfd, struct supertype *st,
1534              struct mdinfo *sra, struct mdinfo *info)
1535 {
1536         /* Add a device to an array, in one of 2 ways. */
1537         int rv;
1538 #ifndef MDASSEMBLE
1539         if (st->ss->external) {
1540                 if (info->disk.state & (1<<MD_DISK_SYNC))
1541                         info->recovery_start = MaxSector;
1542                 else
1543                         info->recovery_start = 0;
1544                 rv = sysfs_add_disk(sra, info, 0);
1545                 if (! rv) {
1546                         struct mdinfo *sd2;
1547                         for (sd2 = sra->devs; sd2; sd2=sd2->next)
1548                                 if (sd2 == info)
1549                                         break;
1550                         if (sd2 == NULL) {
1551                                 sd2 = malloc(sizeof(*sd2));
1552                                 *sd2 = *info;
1553                                 sd2->next = sra->devs;
1554                                 sra->devs = sd2;
1555                         }
1556                 }
1557         } else
1558 #endif
1559                 rv = ioctl(mdfd, ADD_NEW_DISK, &info->disk);
1560         return rv;
1561 }
1562
1563 int set_array_info(int mdfd, struct supertype *st, struct mdinfo *info)
1564 {
1565         /* Initialise kernel's knowledge of array.
1566          * This varies between externally managed arrays
1567          * and older kernels
1568          */
1569         int vers = md_get_version(mdfd);
1570         int rv;
1571
1572 #ifndef MDASSEMBLE
1573         if (st->ss->external)
1574                 rv = sysfs_set_array(info, vers);
1575         else
1576 #endif
1577                 if ((vers % 100) >= 1) { /* can use different versions */
1578                 mdu_array_info_t inf;
1579                 memset(&inf, 0, sizeof(inf));
1580                 inf.major_version = info->array.major_version;
1581                 inf.minor_version = info->array.minor_version;
1582                 rv = ioctl(mdfd, SET_ARRAY_INFO, &inf);
1583         } else
1584                 rv = ioctl(mdfd, SET_ARRAY_INFO, NULL);
1585         return rv;
1586 }
1587
1588 unsigned long long min_recovery_start(struct mdinfo *array)
1589 {
1590         /* find the minimum recovery_start in an array for metadata
1591          * formats that only record per-array recovery progress instead
1592          * of per-device
1593          */
1594         unsigned long long recovery_start = MaxSector;
1595         struct mdinfo *d;
1596
1597         for (d = array->devs; d; d = d->next)
1598                 recovery_start = min(recovery_start, d->recovery_start);
1599
1600         return recovery_start;
1601 }
1602
1603 char *devnum2devname(int num)
1604 {
1605         char name[100];
1606         if (num >= 0)
1607                 sprintf(name, "md%d", num);
1608         else
1609                 sprintf(name, "md_d%d", -1-num);
1610         return strdup(name);
1611 }
1612
1613 int devname2devnum(char *name)
1614 {
1615         char *ep;
1616         int num;
1617         if (strncmp(name, "md_d", 4)==0)
1618                 num = -1-strtoul(name+4, &ep, 10);
1619         else
1620                 num = strtoul(name+2, &ep, 10);
1621         return num;
1622 }
1623
1624 int stat2devnum(struct stat *st)
1625 {
1626         char path[30];
1627         char link[200];
1628         char *cp;
1629         int n;
1630
1631         if ((S_IFMT & st->st_mode) == S_IFBLK) {
1632                 if (major(st->st_rdev) == MD_MAJOR)
1633                         return minor(st->st_rdev);
1634                 else if (major(st->st_rdev) == (unsigned)get_mdp_major())
1635                         return -1- (minor(st->st_rdev)>>MdpMinorShift);
1636
1637                 /* must be an extended-minor partition. Look at the
1638                  * /sys/dev/block/%d:%d link which must look like
1639                  * ../../block/mdXXX/mdXXXpYY
1640                  */
1641                 sprintf(path, "/sys/dev/block/%d:%d", major(st->st_rdev),
1642                         minor(st->st_rdev));
1643                 n = readlink(path, link, sizeof(link)-1);
1644                 if (n <= 0)
1645                         return NoMdDev;
1646                 link[n] = 0;
1647                 cp = strrchr(link, '/');
1648                 if (cp) *cp = 0;
1649                 cp = strchr(link, '/');
1650                 if (cp && strncmp(cp, "/md", 3) == 0)
1651                         return devname2devnum(cp+1);
1652         }
1653         return NoMdDev;
1654
1655 }
1656
1657 int fd2devnum(int fd)
1658 {
1659         struct stat stb;
1660         if (fstat(fd, &stb) == 0)
1661                 return stat2devnum(&stb);
1662         return NoMdDev;
1663 }
1664
1665 int mdmon_pid(int devnum)
1666 {
1667         char path[100];
1668         char pid[10];
1669         int fd;
1670         int n;
1671         char *devname = devnum2devname(devnum);
1672
1673         sprintf(path, "%s/%s.pid", MDMON_DIR, devname);
1674         free(devname);
1675
1676         fd = open(path, O_RDONLY | O_NOATIME, 0);
1677
1678         if (fd < 0)
1679                 return -1;
1680         n = read(fd, pid, 9);
1681         close(fd);
1682         if (n <= 0)
1683                 return -1;
1684         return atoi(pid);
1685 }
1686
1687 int mdmon_running(int devnum)
1688 {
1689         int pid = mdmon_pid(devnum);
1690         if (pid <= 0)
1691                 return 0;
1692         if (kill(pid, 0) == 0)
1693                 return 1;
1694         return 0;
1695 }
1696
1697 int start_mdmon(int devnum)
1698 {
1699         int i;
1700         int len;
1701         pid_t pid;      
1702         int status;
1703         char pathbuf[1024];
1704         char *paths[4] = {
1705                 pathbuf,
1706                 "/sbin/mdmon",
1707                 "mdmon",
1708                 NULL
1709         };
1710
1711         if (check_env("MDADM_NO_MDMON"))
1712                 return 0;
1713
1714         len = readlink("/proc/self/exe", pathbuf, sizeof(pathbuf));
1715         if (len > 0) {
1716                 char *sl;
1717                 pathbuf[len] = 0;
1718                 sl = strrchr(pathbuf, '/');
1719                 if (sl)
1720                         sl++;
1721                 else
1722                         sl = pathbuf;
1723                 strcpy(sl, "mdmon");
1724         } else
1725                 pathbuf[0] = '\0';
1726
1727         switch(fork()) {
1728         case 0:
1729                 /* FIXME yuk. CLOSE_EXEC?? */
1730                 for (i=3; i < 100; i++)
1731                         close(i);
1732                 for (i=0; paths[i]; i++)
1733                         if (paths[i][0])
1734                                 execl(paths[i], "mdmon",
1735                                       devnum2devname(devnum),
1736                                       NULL);
1737                 exit(1);
1738         case -1: fprintf(stderr, Name ": cannot run mdmon. "
1739                          "Array remains readonly\n");
1740                 return -1;
1741         default: /* parent - good */
1742                 pid = wait(&status);
1743                 if (pid < 0 || status != 0)
1744                         return -1;
1745         }
1746         return 0;
1747 }
1748
1749 int check_env(char *name)
1750 {
1751         char *val = getenv(name);
1752
1753         if (val && atoi(val) == 1)
1754                 return 1;
1755
1756         return 0;
1757 }
1758
1759 __u32 random32(void)
1760 {
1761         __u32 rv;
1762         int rfd = open("/dev/urandom", O_RDONLY);
1763         if (rfd < 0 || read(rfd, &rv, 4) != 4)
1764                 rv = random();
1765         if (rfd >= 0)
1766                 close(rfd);
1767         return rv;
1768 }
1769
1770 #ifndef MDASSEMBLE
1771 int flush_metadata_updates(struct supertype *st)
1772 {
1773         int sfd;
1774         if (!st->updates) {
1775                 st->update_tail = NULL;
1776                 return -1;
1777         }
1778
1779         sfd = connect_monitor(devnum2devname(st->container_dev));
1780         if (sfd < 0)
1781                 return -1;
1782
1783         while (st->updates) {
1784                 struct metadata_update *mu = st->updates;
1785                 st->updates = mu->next;
1786
1787                 send_message(sfd, mu, 0);
1788                 wait_reply(sfd, 0);
1789                 free(mu->buf);
1790                 free(mu);
1791         }
1792         ack(sfd, 0);
1793         wait_reply(sfd, 0);
1794         close(sfd);
1795         st->update_tail = NULL;
1796         return 0;
1797 }
1798
1799 void append_metadata_update(struct supertype *st, void *buf, int len)
1800 {
1801
1802         struct metadata_update *mu = malloc(sizeof(*mu));
1803
1804         mu->buf = buf;
1805         mu->len = len;
1806         mu->space = NULL;
1807         mu->next = NULL;
1808         *st->update_tail = mu;
1809         st->update_tail = &mu->next;
1810 }
1811 #endif /* MDASSEMBLE */
1812
1813 #ifdef __TINYC__
1814 /* tinyc doesn't optimize this check in ioctl.h out ... */
1815 unsigned int __invalid_size_argument_for_IOC = 0;
1816 #endif
1817