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