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