#include <dirent.h>
#include <signal.h>
+int __offroot;
+
/*
* following taken from linux/blkpg.h because they aren't
* anywhere else and it isn't safe to #include linux/ * stuff.
* followed by 'K', 'M', or 'G'.
* Without a suffix, K is assumed.
* Number returned is in sectors (half-K)
+ * -1 returned on error.
*/
char *c;
long long s = strtoll(size, &c, 10);
}
}
if (*c)
- s = 0;
+ s = -1;
return s;
}
{
/* Parse the layout string for 'faulty' */
int ln = strcspn(layout, "0123456789");
- char *m = strdup(layout);
+ char *m = xstrdup(layout);
int mode;
m[ln] = 0;
mode = map_name(faultylayout, m);
return rv;
}
-int enough(int level, int raid_disks, int layout, int clean,
- char *avail, int avail_disks)
+int enough(int level, int raid_disks, int layout, int clean, char *avail)
{
int copies, first;
+ int i;
+ int avail_disks = 0;
+
+ for (i = 0; i < raid_disks; i++)
+ avail_disks += !!avail[i];
+
switch (level) {
case 10:
/* This is the tricky one - we need to check
struct mdu_array_info_s array;
struct mdu_disk_info_s disk;
int avail_disks = 0;
- int i;
+ int i, rv;
char *avail;
if (ioctl(fd, GET_ARRAY_INFO, &array) != 0 ||
array.raid_disks <= 0)
return 0;
- avail = calloc(array.raid_disks, 1);
- for (i=0; i < 1024 && array.nr_disks > 0; i++) {
+ avail = xcalloc(array.raid_disks, 1);
+ for (i=0; i < MAX_DISKS && array.nr_disks > 0; i++) {
disk.number = i;
if (ioctl(fd, GET_DISK_INFO, &disk) != 0)
continue;
avail[disk.raid_disk] = 1;
}
/* This is used on an active array, so assume it is clean */
- return enough(array.level, array.raid_disks, array.layout,
- 1,
- avail, avail_disks);
+ rv = enough(array.level, array.raid_disks, array.layout,
+ 1, avail);
+ free(avail);
+ return rv;
}
mtime = sb[44]|(sb[45]|(sb[46]|sb[47]<<8)<<8)<<8;
bsize = sb[24]|(sb[25]|(sb[26]|sb[27]<<8)<<8)<<8;
size = sb[4]|(sb[5]|(sb[6]|sb[7]<<8)<<8)<<8;
- fprintf(stderr, Name ": %s appears to contain an ext2fs file system\n",
+ pr_err("%s appears to contain an ext2fs file system\n",
name);
fprintf(stderr," size=%dK mtime=%s",
size*(1<<bsize), ctime(&mtime));
if (strncmp((char*)sb+52, "ReIsErFs",8)!=0 &&
strncmp((char*)sb+52, "ReIsEr2Fs",9)!=0)
return 0;
- fprintf(stderr, Name ": %s appears to contain a reiserfs file system\n",name);
+ pr_err("%s appears to contain a reiserfs file system\n",name);
size = sb[0]|(sb[1]|(sb[2]|sb[3]<<8)<<8)<<8;
fprintf(stderr, " size = %luK\n", size*4);
struct supertype *st = guess_super(fd);
if (!st) return 0;
+ st->ignore_hw_compat = 1;
st->ss->load_super(st, fd, name);
/* Looks like a raid array .. */
- fprintf(stderr, Name ": %s appears to be part of a raid array:\n",
+ pr_err("%s appears to be part of a raid array:\n",
name);
st->ss->getinfo_super(st, &info, NULL);
st->ss->free_super(st);
return 0;
add = "(y/n) ";
}
- fprintf(stderr, Name ": assuming 'no'\n");
+ pr_err("assuming 'no'\n");
return 0;
}
#endif /* MDASSEMBLE */
* We allow upto 2048Megabytes before converting to
* gigabytes, as that shows more precision and isn't
* too large a number.
- * Terrabytes are not yet handled.
+ * Terabytes are not yet handled.
*/
if (bytes < 5000*1024)
unsigned long long calc_array_size(int level, int raid_disks, int layout,
int chunksize, unsigned long long devsize)
+{
+ if (level == 1)
+ return devsize;
+ devsize &= ~(unsigned long long)((chunksize>>9)-1);
+ return get_data_disks(level, layout, raid_disks) * devsize;
+}
+
+int get_data_disks(int level, int layout, int raid_disks)
{
int data_disks = 0;
switch (level) {
case 10: data_disks = raid_disks / (layout & 255) / ((layout>>8)&255);
break;
}
- devsize &= ~(unsigned long long)((chunksize>>9)-1);
- return data_disks * devsize;
+
+ return data_disks;
}
#if !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO)
char *dev = verstr+1;
subarray = strchr(dev, '/');
- if (subarray)
+ if (subarray) {
*subarray++ = '\0';
- subarray = strdup(subarray);
+ subarray = xstrdup(subarray);
+ }
container = devname2devnum(dev);
if (sra)
sysfs_free(sra);
if (!orig)
return orig;
- st = malloc(sizeof(*st));
- if (!st)
- return st;
- memset(st, 0, sizeof(*st));
+ st = xcalloc(1, sizeof(*st));
st->ss = orig->ss;
st->max_devs = orig->max_devs;
st->minor_version = orig->minor_version;
int bestsuper = -1;
int i;
- st = malloc(sizeof(*st));
- memset(st, 0, sizeof(*st));
+ st = xcalloc(1, sizeof(*st));
st->container_dev = NoMdDev;
for (i=0 ; superlist[i]; i++) {
ldsize <<= 9;
} else {
if (dname)
- fprintf(stderr, Name ": Cannot get size of %s: %s\b",
+ pr_err("Cannot get size of %s: %s\b",
dname, strerror(errno));
return 0;
}
{
struct GPT gpt;
unsigned char empty_gpt_entry[16]= {0};
- struct GPT_part_entry part;
+ struct GPT_part_entry *part;
+ char buf[512];
unsigned long long curr_part_end;
unsigned all_partitions, entry_size;
unsigned part_nr;
/* sanity checks */
if (all_partitions > 1024 ||
- entry_size > 512)
+ entry_size > sizeof(buf))
return -1;
+ part = (struct GPT_part_entry *)buf;
+
for (part_nr=0; part_nr < all_partitions; part_nr++) {
/* read partition entry */
- if (read(fd, &part, entry_size) != (ssize_t)entry_size)
+ if (read(fd, buf, entry_size) != (ssize_t)entry_size)
return 0;
/* is this valid partition? */
- if (memcmp(part.type_guid, empty_gpt_entry, 16) != 0) {
+ if (memcmp(part->type_guid, empty_gpt_entry, 16) != 0) {
/* check the last lba for the current partition */
- curr_part_end = __le64_to_cpu(part.ending_lba);
+ curr_part_end = __le64_to_cpu(part->ending_lba);
if (curr_part_end > *endofpart)
*endofpart = curr_part_end;
}
/* There appears to be a partition table here */
if (freesize == 0) {
/* partitions will not be visible in new device */
- fprintf(stderr,
- Name ": partition table exists on %s but will be lost or\n"
- " meaningless after creating array\n",
- dname);
+ pr_err("partition table exists on %s but will be lost or\n"
+ " meaningless after creating array\n",
+ dname);
return 1;
} else if (endofpart > freesize) {
/* last partition overlaps metadata */
- fprintf(stderr,
- Name ": metadata will over-write last partition on %s.\n",
- dname);
+ pr_err("metadata will over-write last partition on %s.\n",
+ dname);
return 1;
} else if (size && endofpart > size) {
/* partitions will be truncated in new device */
- fprintf(stderr,
- Name ": array size is too small to cover all partitions on %s.\n",
- dname);
+ pr_err("array size is too small to cover all partitions on %s.\n",
+ dname);
return 1;
}
}
int d;
ioctl(mdfd, GET_ARRAY_INFO, ainf);
- for (d = 0 ; d < 1024 ; d++) {
+ for (d = 0 ; d < MAX_DISKS ; d++) {
if (ioctl(mdfd, GET_DISK_INFO, disk) == 0 &&
(disk->major || disk->minor))
return;
fd = open(dev, O_RDWR|O_EXCL);
if (fd < 0) {
if (!quiet)
- fprintf(stderr, Name ": Couldn't open %s, aborting\n",
+ pr_err("Couldn't open %s, aborting\n",
dev);
- return 2;
+ return -1;
}
st->devnum = fd2devnum(fd);
if (st->devnum == NoMdDev) {
if (!quiet)
- fprintf(stderr,
- Name ": Failed to determine device number for %s\n",
- dev);
+ pr_err("Failed to determine device number for %s\n",
+ dev);
goto close_fd;
}
mdi = sysfs_read(fd, st->devnum, GET_VERSION|GET_LEVEL);
if (!mdi) {
if (!quiet)
- fprintf(stderr, Name ": Failed to read sysfs for %s\n",
+ pr_err("Failed to read sysfs for %s\n",
dev);
goto close_fd;
}
if (mdi->array.level != UnSet) {
if (!quiet)
- fprintf(stderr, Name ": %s is not a container\n", dev);
+ pr_err("%s is not a container\n", dev);
goto free_sysfs;
}
st->ss = version_to_superswitch(mdi->text_version);
if (!st->ss) {
if (!quiet)
- fprintf(stderr,
- Name ": Operation not supported for %s metadata\n",
- mdi->text_version);
+ pr_err("Operation not supported for %s metadata\n",
+ mdi->text_version);
goto free_sysfs;
}
st->devname = devnum2devname(st->devnum);
if (!st->devname) {
if (!quiet)
- fprintf(stderr, Name ": Failed to allocate device name\n");
+ pr_err("Failed to allocate device name\n");
goto free_sysfs;
}
if (!st->ss->load_container) {
if (!quiet)
- fprintf(stderr, Name ": %s is not a container\n", dev);
+ pr_err("%s is not a container\n", dev);
goto free_name;
}
if (st->ss->load_container(st, fd, NULL)) {
if (!quiet)
- fprintf(stderr, Name ": Failed to load metadata for %s\n",
+ pr_err("Failed to load metadata for %s\n",
dev);
goto free_name;
}
info = st->ss->container_content(st, subarray);
if (!info) {
if (!quiet)
- fprintf(stderr, Name ": Failed to find subarray-%s in %s\n",
+ pr_err("Failed to find subarray-%s in %s\n",
subarray, dev);
goto free_super;
}
if (sd2 == info)
break;
if (sd2 == NULL) {
- sd2 = malloc(sizeof(*sd2));
+ sd2 = xmalloc(sizeof(*sd2));
*sd2 = *info;
sd2->next = sra->devs;
sra->devs = sd2;
int start_mdmon(int devnum)
{
- int i;
+ int i, skipped;
int len;
pid_t pid;
int status;
if (check_env("MDADM_NO_MDMON"))
return 0;
- len = readlink("/proc/self/exe", pathbuf, sizeof(pathbuf));
+ len = readlink("/proc/self/exe", pathbuf, sizeof(pathbuf)-1);
if (len > 0) {
char *sl;
pathbuf[len] = 0;
switch(fork()) {
case 0:
/* FIXME yuk. CLOSE_EXEC?? */
- for (i=3; i < 100; i++)
- close(i);
+ skipped = 0;
+ for (i=3; skipped < 20; i++)
+ if (close(i) < 0)
+ skipped++;
+ else
+ skipped = 0;
+
for (i=0; paths[i]; i++)
- if (paths[i][0])
- execl(paths[i], "mdmon",
- devnum2devname(devnum),
- NULL);
+ if (paths[i][0]) {
+ if (__offroot) {
+ execl(paths[i], "mdmon", "--offroot",
+ devnum2devname(devnum),
+ NULL);
+ } else {
+ execl(paths[i], "mdmon",
+ devnum2devname(devnum),
+ NULL);
+ }
+ }
exit(1);
- case -1: fprintf(stderr, Name ": cannot run mdmon. "
+ case -1: pr_err("cannot run mdmon. "
"Array remains readonly\n");
return -1;
default: /* parent - good */
void append_metadata_update(struct supertype *st, void *buf, int len)
{
- struct metadata_update *mu = malloc(sizeof(*mu));
+ struct metadata_update *mu = xmalloc(sizeof(*mu));
mu->buf = buf;
mu->len = len;
if (check_env("MDADM_EXPERIMENTAL"))
return 1;
else {
- fprintf(stderr, Name ": To use this feature MDADM_EXPERIMENTAL enviroment variable has to defined.\n");
+ pr_err("To use this feature MDADM_EXPERIMENTAL"
+ " environment variable has to be defined.\n");
return 0;
}
}
}
return disks;
}
+
+void *xmalloc(size_t len)
+{
+ void *rv = malloc(len);
+ char *msg;
+ if (rv)
+ return rv;
+ msg = Name ": memory allocation failure - aborting\n";
+ exit(4+!!write(2, msg, strlen(msg)));
+}
+
+void *xrealloc(void *ptr, size_t len)
+{
+ void *rv = realloc(ptr, len);
+ char *msg;
+ if (rv)
+ return rv;
+ msg = Name ": memory allocation failure - aborting\n";
+ exit(4+!!write(2, msg, strlen(msg)));
+}
+
+void *xcalloc(size_t num, size_t size)
+{
+ void *rv = calloc(num, size);
+ char *msg;
+ if (rv)
+ return rv;
+ msg = Name ": memory allocation failure - aborting\n";
+ exit(4+!!write(2, msg, strlen(msg)));
+}
+
+char *xstrdup(const char *str)
+{
+ char *rv = strdup(str);
+ char *msg;
+ if (rv)
+ return rv;
+ msg = Name ": memory allocation failure - aborting\n";
+ exit(4+!!write(2, msg, strlen(msg)));
+}
projects / thirdparty / mdadm.git / blobdiff