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