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