X-Git-Url: http://git.ipfire.org/?p=thirdparty%2Fmdadm.git;a=blobdiff_plain;f=util.c;h=d0765a6dabad4c678fc9ec7ca7dfc069d28802b6;hp=d22b0d085473925eb2010eb1dc8392aaa681ee02;hb=72d566f68d495261608a900b2d8cb8d037cd9178;hpb=d19e3cfb6627c40e3a28454ebc2098c0e19b9a77 diff --git a/util.c b/util.c index d22b0d08..d0765a6d 100644 --- a/util.c +++ b/util.c @@ -32,6 +32,8 @@ #include #include +int __offroot; + /* * following taken from linux/blkpg.h because they aren't * anywhere else and it isn't safe to #include linux/ * stuff. @@ -65,55 +67,7 @@ struct blkpg_partition { char volname[BLKPG_VOLNAMELTH]; /* volume label */ }; -/* partition table structures so we can check metadata position - * against the end of the last partition. - * Only handle MBR ant GPT partition tables. - */ -struct MBR_part_record { - __u8 bootable; - __u8 first_head; - __u8 first_sector; - __u8 first_cyl; - __u8 part_type; - __u8 last_head; - __u8 last_sector; - __u8 last_cyl; - __u32 first_sect_lba; - __u32 blocks_num; -}; - -struct MBR { - __u8 pad[446]; - struct MBR_part_record parts[4]; - __u16 magic; -} __attribute__((packed)); - -struct GPT_part_entry { - unsigned char type_guid[16]; - unsigned char partition_guid[16]; - __u64 starting_lba; - __u64 ending_lba; - unsigned char attr_bits[8]; - unsigned char name[72]; -} __attribute__((packed)); - -struct GPT { - __u64 magic; - __u32 revision; - __u32 header_size; - __u32 crc; - __u32 pad1; - __u64 current_lba; - __u64 backup_lba; - __u64 first_lba; - __u64 last_lba; - __u8 guid[16]; - __u64 part_start; - __u32 part_cnt; - __u32 part_size; - __u32 part_crc; - __u8 pad2[420]; -} __attribute__((packed)); +#include "part.h" /* Force a compilation error if condition is true */ #define BUILD_BUG_ON(condition) ((void)BUILD_BUG_ON_ZERO(condition)) @@ -124,14 +78,6 @@ struct GPT { aren't permitted). */ #define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:-!!(e); })) - -/* MBR/GPT magic numbers */ -#define MBR_SIGNATURE_MAGIC __cpu_to_le16(0xAA55) -#define GPT_SIGNATURE_MAGIC __cpu_to_le64(0x5452415020494645ULL) - -#define MBR_PARTITIONS 4 -#define MBR_GPT_PARTITION_TYPE 0xEE - /* * Parse a 128 bit uuid in 4 integers * format is 32 hexx nibbles with options :. separator @@ -202,27 +148,53 @@ int get_linux_version() { struct utsname name; char *cp; - int a,b,c; + int a = 0, b = 0,c = 0; if (uname(&name) <0) return -1; cp = name.release; a = strtoul(cp, &cp, 10); - if (*cp != '.') return -1; - b = strtoul(cp+1, &cp, 10); - if (*cp != '.') return -1; - c = strtoul(cp+1, NULL, 10); + if (*cp == '.') + b = strtoul(cp+1, &cp, 10); + if (*cp == '.') + c = strtoul(cp+1, &cp, 10); return (a*1000000)+(b*1000)+c; } #ifndef MDASSEMBLE +int mdadm_version(char *version) +{ + int a, b, c; + char *cp; + + if (!version) + version = Version; + + cp = strchr(version, '-'); + if (!cp || *(cp+1) != ' ' || *(cp+2) != 'v') + return -1; + cp += 3; + a = strtoul(cp, &cp, 10); + if (*cp != '.') + return -1; + b = strtoul(cp+1, &cp, 10); + if (*cp == '.') + c = strtoul(cp+1, &cp, 10); + else + c = 0; + if (*cp != ' ' && *cp != '-') + return -1; + return (a*1000000)+(b*1000)+c; +} + long long parse_size(char *size) { /* parse 'size' which should be a number optionally * 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); @@ -244,7 +216,7 @@ long long parse_size(char *size) } } if (*c) - s = 0; + s = -1; return s; } @@ -272,7 +244,7 @@ int parse_layout_faulty(char *layout) { /* 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); @@ -326,11 +298,29 @@ int test_partition(int fd) return 1; } +int test_partition_from_id(dev_t id) +{ + char buf[20]; + int fd, rv; + + sprintf(buf, "%d:%d", major(id), minor(id)); + fd = dev_open(buf, O_RDONLY); + if (fd < 0) + return -1; + rv = test_partition(fd); + close(fd); + 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 @@ -376,13 +366,45 @@ int enough(int level, int raid_disks, int layout, int clean, } } -const int uuid_match_any[4] = { ~0, ~0, ~0, ~0 }; -int same_uuid(int a[4], int b[4], int swapuuid) +int enough_fd(int fd) { - if (memcmp(a, uuid_match_any, sizeof(int[4])) == 0 || - memcmp(b, uuid_match_any, sizeof(int[4])) == 0) - return 1; + struct mdu_array_info_s array; + struct mdu_disk_info_s disk; + int avail_disks = 0; + int i, rv; + char *avail; + + if (ioctl(fd, GET_ARRAY_INFO, &array) != 0 || + array.raid_disks <= 0) + return 0; + 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; + if (disk.major == 0 && disk.minor == 0) + continue; + array.nr_disks--; + + if (! (disk.state & (1<= array.raid_disks) + continue; + avail_disks++; + avail[disk.raid_disk] = 1; + } + /* This is used on an active array, so assume it is clean */ + rv = enough(array.level, array.raid_disks, array.layout, + 1, avail); + free(avail); + return rv; +} + +const int uuid_zero[4] = { 0, 0, 0, 0 }; + +int same_uuid(int a[4], int b[4], int swapuuid) +{ if (swapuuid) { /* parse uuids are hostendian. * uuid's from some superblocks are big-ending @@ -483,7 +505,7 @@ int check_ext2(int fd, char *name) 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<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); + st->ss->getinfo_super(st, &info, NULL); st->ss->free_super(st); crtime = info.array.ctime; level = map_num(pers, info.array.level); @@ -552,32 +575,11 @@ int ask(char *mesg) return 0; add = "(y/n) "; } - fprintf(stderr, Name ": assuming 'no'\n"); + pr_err("assuming 'no'\n"); return 0; } #endif /* MDASSEMBLE */ -char *map_num(mapping_t *map, int num) -{ - while (map->name) { - if (map->num == num) - return map->name; - map++; - } - return NULL; -} - -int map_name(mapping_t *map, char *name) -{ - while (map->name) { - if (strcmp(map->name, name)==0) - return map->num; - map++; - } - return UnSet; -} - - int is_standard(char *dev, int *nump) { /* tests if dev is a "standard" md dev name. @@ -614,122 +616,6 @@ int is_standard(char *dev, int *nump) return type; } - -/* - * convert a major/minor pair for a block device into a name in /dev, if possible. - * On the first call, walk /dev collecting name. - * Put them in a simple linked listfor now. - */ -struct devmap { - int major, minor; - char *name; - struct devmap *next; -} *devlist = NULL; -int devlist_ready = 0; - -int add_dev(const char *name, const struct stat *stb, int flag, struct FTW *s) -{ - struct stat st; - - if (S_ISLNK(stb->st_mode)) { - if (stat(name, &st) != 0) - return 0; - stb = &st; - } - - if ((stb->st_mode&S_IFMT)== S_IFBLK) { - char *n = strdup(name); - struct devmap *dm = malloc(sizeof(*dm)); - if (strncmp(n, "/dev/./", 7)==0) - strcpy(n+4, name+6); - if (dm) { - dm->major = major(stb->st_rdev); - dm->minor = minor(stb->st_rdev); - dm->name = n; - dm->next = devlist; - devlist = dm; - } - } - return 0; -} - -#ifndef HAVE_NFTW -#ifdef HAVE_FTW -int add_dev_1(const char *name, const struct stat *stb, int flag) -{ - return add_dev(name, stb, flag, NULL); -} -int nftw(const char *path, int (*han)(const char *name, const struct stat *stb, int flag, struct FTW *s), int nopenfd, int flags) -{ - return ftw(path, add_dev_1, nopenfd); -} -#else -int nftw(const char *path, int (*han)(const char *name, const struct stat *stb, int flag, struct FTW *s), int nopenfd, int flags) -{ - return 0; -} -#endif /* HAVE_FTW */ -#endif /* HAVE_NFTW */ - -/* - * Find a block device with the right major/minor number. - * If we find multiple names, choose the shortest. - * If we find a name in /dev/md/, we prefer that. - * This applies only to names for MD devices. - */ -char *map_dev(int major, int minor, int create) -{ - struct devmap *p; - char *regular = NULL, *preferred=NULL; - int did_check = 0; - - if (major == 0 && minor == 0) - return NULL; - - retry: - if (!devlist_ready) { - char *dev = "/dev"; - struct stat stb; - while(devlist) { - struct devmap *d = devlist; - devlist = d->next; - free(d->name); - free(d); - } - if (lstat(dev, &stb)==0 && - S_ISLNK(stb.st_mode)) - dev = "/dev/."; - nftw(dev, add_dev, 10, FTW_PHYS); - devlist_ready=1; - did_check = 1; - } - - for (p=devlist; p; p=p->next) - if (p->major == major && - p->minor == minor) { - if (strncmp(p->name, "/dev/md/",8) == 0) { - if (preferred == NULL || - strlen(p->name) < strlen(preferred)) - preferred = p->name; - } else { - if (regular == NULL || - strlen(p->name) < strlen(regular)) - regular = p->name; - } - } - if (!regular && !preferred && !did_check) { - devlist_ready = 0; - goto retry; - } - if (create && !regular && !preferred) { - static char buf[30]; - snprintf(buf, sizeof(buf), "%d:%d", major, minor); - regular = buf; - } - - return preferred ? preferred : regular; -} - unsigned long calc_csum(void *super, int bytes) { unsigned long long newcsum = 0; @@ -763,7 +649,7 @@ char *human_size(long long bytes) * 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) @@ -825,6 +711,14 @@ void print_r10_layout(int layout) 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) { @@ -836,36 +730,8 @@ unsigned long long calc_array_size(int level, int raid_disks, int layout, case 10: data_disks = raid_disks / (layout & 255) / ((layout>>8)&255); break; } - devsize &= ~(unsigned long long)((chunksize>>9)-1); - return data_disks * devsize; -} - -int get_mdp_major(void) -{ -static int mdp_major = -1; - FILE *fl; - char *w; - int have_block = 0; - int have_devices = 0; - int last_num = -1; - if (mdp_major != -1) - return mdp_major; - fl = fopen("/proc/devices", "r"); - if (!fl) - return -1; - while ((w = conf_word(fl, 1))) { - if (have_block && strcmp(w, "devices:")==0) - have_devices = 1; - have_block = (strcmp(w, "Block")==0); - if (isdigit(w[0])) - last_num = atoi(w); - if (have_devices && strcmp(w, "mdp")==0) - mdp_major = last_num; - free(w); - } - fclose(fl); - return mdp_major; + return data_disks; } #if !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO) @@ -959,40 +825,64 @@ int dev_open(char *dev, int flags) int minor; if (!dev) return -1; + flags |= O_DIRECT; major = strtoul(dev, &e, 0); if (e > dev && *e == ':' && e[1] && (minor = strtoul(e+1, &e, 0)) >= 0 && *e == 0) { - snprintf(devname, sizeof(devname), "/dev/.tmp.md.%d:%d:%d", - (int)getpid(), major, minor); - if (mknod(devname, S_IFBLK|0600, makedev(major, minor))==0) { - fd = open(devname, flags|O_DIRECT); - unlink(devname); + char *path = map_dev(major, minor, 0); + if (path) + fd = open(path, flags); + if (fd < 0) { + snprintf(devname, sizeof(devname), "/dev/.tmp.md.%d:%d:%d", + (int)getpid(), major, minor); + if (mknod(devname, S_IFBLK|0600, makedev(major, minor))==0) { + fd = open(devname, flags); + unlink(devname); + } + } + if (fd < 0) { + snprintf(devname, sizeof(devname), "/tmp/.tmp.md.%d:%d:%d", + (int)getpid(), major, minor); + if (mknod(devname, S_IFBLK|0600, makedev(major, minor))==0) { + fd = open(devname, flags); + unlink(devname); + } } } else - fd = open(dev, flags|O_DIRECT); + fd = open(dev, flags); return fd; } -int open_dev(int devnum) +int open_dev_flags(int devnum, int flags) { char buf[20]; sprintf(buf, "%d:%d", dev2major(devnum), dev2minor(devnum)); - return dev_open(buf, O_RDWR); + return dev_open(buf, flags); +} + +int open_dev(int devnum) +{ + return open_dev_flags(devnum, O_RDONLY); } int open_dev_excl(int devnum) { char buf[20]; int i; + int flags = O_RDWR; sprintf(buf, "%d:%d", dev2major(devnum), dev2minor(devnum)); for (i=0 ; i<25 ; i++) { - int fd = dev_open(buf, O_RDWR|O_EXCL); + int fd = dev_open(buf, flags|O_EXCL); if (fd >= 0) return fd; + if (errno == EACCES && flags == O_RDWR) { + flags = O_RDONLY; + continue; + } if (errno != EBUSY) return fd; usleep(200000); @@ -1035,11 +925,16 @@ void wait_for(char *dev, int fd) dprintf("%s: timeout waiting for %s\n", __func__, dev); } -struct superswitch *superlist[] = { &super0, &super1, &super_ddf, &super_imsm, NULL }; +struct superswitch *superlist[] = +{ + &super0, &super1, + &super_ddf, &super_imsm, + &mbr, &gpt, + NULL }; #if !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO) -struct supertype *super_by_fd(int fd) +struct supertype *super_by_fd(int fd, char **subarrayp) { mdu_array_info_t array; int vers; @@ -1050,6 +945,7 @@ struct supertype *super_by_fd(int fd) char version[20]; int i; char *subarray = NULL; + int container = NoMdDev; sra = sysfs_read(fd, 0, GET_VERSION); @@ -1071,15 +967,16 @@ struct supertype *super_by_fd(int fd) } if (minor == -2 && is_subarray(verstr)) { char *dev = verstr+1; + subarray = strchr(dev, '/'); - int devnum; - if (subarray) + if (subarray) { *subarray++ = '\0'; - devnum = devname2devnum(dev); - subarray = strdup(subarray); + subarray = xstrdup(subarray); + } + container = devname2devnum(dev); if (sra) sysfs_free(sra); - sra = sysfs_read(-1, devnum, GET_VERSION); + sra = sysfs_read(-1, container, GET_VERSION); if (sra && sra->text_version[0]) verstr = sra->text_version; else @@ -1093,17 +990,33 @@ struct supertype *super_by_fd(int fd) sysfs_free(sra); if (st) { st->sb = NULL; - if (subarray) { - strncpy(st->subarray, subarray, 32); - st->subarray[31] = 0; - free(subarray); - } else - st->subarray[0] = 0; - } + if (subarrayp) + *subarrayp = subarray; + st->container_dev = container; + st->devnum = fd2devnum(fd); + } else + free(subarray); + return st; } #endif /* !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO) */ +int dev_size_from_id(dev_t id, unsigned long long *size) +{ + char buf[20]; + int fd; + + sprintf(buf, "%d:%d", major(id), minor(id)); + fd = dev_open(buf, O_RDONLY); + if (fd < 0) + return 0; + if (get_dev_size(fd, NULL, size)) { + close(fd); + return 1; + } + close(fd); + return 0; +} struct supertype *dup_super(struct supertype *orig) { @@ -1111,39 +1024,42 @@ struct supertype *dup_super(struct supertype *orig) 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; - strcpy(st->subarray, orig->subarray); st->sb = NULL; st->info = NULL; return st; } -struct supertype *guess_super(int fd) +struct supertype *guess_super_type(int fd, enum guess_types guess_type) { /* try each load_super to find the best match, * and return the best superswitch */ struct superswitch *ss; struct supertype *st; - unsigned long besttime = 0; + time_t besttime = 0; int bestsuper = -1; int i; - st = malloc(sizeof(*st)); + st = xcalloc(1, sizeof(*st)); + st->container_dev = NoMdDev; + for (i=0 ; superlist[i]; i++) { int rv; ss = superlist[i]; + if (guess_type == guess_array && ss->add_to_super == NULL) + continue; + if (guess_type == guess_partitions && ss->add_to_super != NULL) + continue; memset(st, 0, sizeof(*st)); + st->ignore_hw_compat = 1; rv = ss->load_super(st, fd, NULL); if (rv == 0) { struct mdinfo info; - st->ss->getinfo_super(st, &info); + st->ss->getinfo_super(st, &info, NULL); if (bestsuper == -1 || besttime < info.array.ctime) { bestsuper = i; @@ -1155,9 +1071,11 @@ struct supertype *guess_super(int fd) if (bestsuper != -1) { int rv; memset(st, 0, sizeof(*st)); + st->ignore_hw_compat = 1; rv = superlist[bestsuper]->load_super(st, fd, NULL); if (rv == 0) { superlist[bestsuper]->free_super(st); + st->ignore_hw_compat = 0; return st; } } @@ -1184,7 +1102,7 @@ int get_dev_size(int fd, char *dname, unsigned long long *sizep) 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; } @@ -1193,6 +1111,20 @@ int get_dev_size(int fd, char *dname, unsigned long long *sizep) return 1; } +/* Return true if this can only be a container, not a member device. + * i.e. is and md device and size is zero + */ +int must_be_container(int fd) +{ + unsigned long long size; + if (md_get_version(fd) < 0) + return 0; + if (get_dev_size(fd, NULL, &size) == 0) + return 1; + if (size == 0) + return 1; + return 0; +} /* Sets endofpart parameter to the last block used by the last GPT partition on the device. * Returns: 1 if successful @@ -1202,18 +1134,19 @@ int get_dev_size(int fd, char *dname, unsigned long long *sizep) static int get_gpt_last_partition_end(int fd, unsigned long long *endofpart) { struct GPT gpt; - unsigned char buf[512]; unsigned char empty_gpt_entry[16]= {0}; struct GPT_part_entry *part; + char buf[512]; unsigned long long curr_part_end; unsigned all_partitions, entry_size; - int part_nr; + unsigned part_nr; *endofpart = 0; BUILD_BUG_ON(sizeof(gpt) != 512); - /* read GPT header */ + /* skip protective MBR */ lseek(fd, 512, SEEK_SET); + /* read GPT header */ if (read(fd, &gpt, 512) != 512) return 0; @@ -1227,16 +1160,16 @@ static int get_gpt_last_partition_end(int fd, unsigned long long *endofpart) /* sanity checks */ if (all_partitions > 1024 || - entry_size > 512) + entry_size > sizeof(buf)) return -1; - /* read first GPT partition entries */ - if (read(fd, buf, 512) != 512) - return 0; - - part = (struct GPT_part_entry*)buf; + part = (struct GPT_part_entry *)buf; for (part_nr=0; part_nr < all_partitions; part_nr++) { + /* read partition entry */ + 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) { /* check the last lba for the current partition */ @@ -1245,13 +1178,6 @@ static int get_gpt_last_partition_end(int fd, unsigned long long *endofpart) *endofpart = curr_part_end; } - part = (struct GPT_part_entry*)((unsigned char*)part + entry_size); - - if ((unsigned char *)part >= buf + 512) { - if (read(fd, buf, 512) != 512) - return 0; - part = (struct GPT_part_entry*)buf; - } } return 1; } @@ -1266,7 +1192,7 @@ static int get_last_partition_end(int fd, unsigned long long *endofpart) struct MBR boot_sect; struct MBR_part_record *part; unsigned long long curr_part_end; - int part_nr; + unsigned part_nr; int retval = 0; *endofpart = 0; @@ -1305,7 +1231,8 @@ static int get_last_partition_end(int fd, unsigned long long *endofpart) return retval; } -int check_partitions(int fd, char *dname, unsigned long long freesize) +int check_partitions(int fd, char *dname, unsigned long long freesize, + unsigned long long size) { /* * Check where the last partition ends @@ -1317,16 +1244,19 @@ int check_partitions(int fd, char *dname, unsigned long long freesize) /* 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 */ + pr_err("array size is too small to cover all partitions on %s.\n", + dname); return 1; } } @@ -1336,10 +1266,13 @@ int check_partitions(int fd, char *dname, unsigned long long freesize) void get_one_disk(int mdfd, mdu_array_info_t *ainf, mdu_disk_info_t *disk) { int d; + ioctl(mdfd, GET_ARRAY_INFO, ainf); - for (d = 0 ; d < ainf->raid_disks + ainf->nr_disks ; d++) - if (ioctl(mdfd, GET_DISK_INFO, disk) == 0) + for (d = 0 ; d < MAX_DISKS ; d++) { + if (ioctl(mdfd, GET_DISK_INFO, disk) == 0 && + (disk->major || disk->minor)) return; + } } int open_container(int fd) @@ -1376,7 +1309,7 @@ int open_container(int fd) continue; n = read(dfd, buf, sizeof(buf)); close(dfd); - if (n <= 0 || n >= sizeof(buf)) + if (n <= 0 || (unsigned)n >= sizeof(buf)) continue; buf[n] = 0; if (sscanf(buf, "%d:%d", &major, &minor) != 2) @@ -1423,14 +1356,10 @@ int is_subarray_active(char *subarray, char *container) struct mdstat_ent *mdstat = mdstat_read(0, 0); struct mdstat_ent *ent; - for (ent = mdstat; ent; ent = ent->next) { - if (is_container_member(ent, container)) { - char *inst = &ent->metadata_version[10+strlen(container)+1]; - - if (strcmp(inst, subarray) == 0) + for (ent = mdstat; ent; ent = ent->next) + if (is_container_member(ent, container)) + if (strcmp(to_subarray(ent, container), subarray) == 0) break; - } - } free_mdstat(mdstat); @@ -1439,75 +1368,83 @@ int is_subarray_active(char *subarray, char *container) /* open_subarray - opens a subarray in a container * @dev: container device name - * @st: supertype with only ->subarray set + * @st: empty supertype * @quiet: block reporting errors flag * * On success returns an fd to a container and fills in *st */ -int open_subarray(char *dev, struct supertype *st, int quiet) +int open_subarray(char *dev, char *subarray, struct supertype *st, int quiet) { struct mdinfo *mdi; + struct mdinfo *info; int fd, err = 1; 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_super(st, fd, NULL)) { + if (!st->ss->load_container) { + if (!quiet) + 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 find subarray-%s in %s\n", - st->subarray, dev); + pr_err("Failed to load metadata for %s\n", + dev); goto free_name; } - if (!st->loaded_container) { + info = st->ss->container_content(st, subarray); + if (!info) { if (!quiet) - fprintf(stderr, Name ": %s is not a container\n", dev); + pr_err("Failed to find subarray-%s in %s\n", + subarray, dev); goto free_super; } + free(info); err = 0; @@ -1547,7 +1484,7 @@ int add_disk(int mdfd, struct supertype *st, if (sd2 == info) break; if (sd2 == NULL) { - sd2 = malloc(sizeof(*sd2)); + sd2 = xmalloc(sizeof(*sd2)); *sd2 = *info; sd2->next = sra->devs; sra->devs = sd2; @@ -1559,6 +1496,21 @@ int add_disk(int mdfd, struct supertype *st, return rv; } +int remove_disk(int mdfd, struct supertype *st, + struct mdinfo *sra, struct mdinfo *info) +{ + int rv; + /* Remove the disk given by 'info' from the array */ +#ifndef MDASSEMBLE + if (st->ss->external) + rv = sysfs_set_str(sra, info, "slot", "none"); + else +#endif + rv = ioctl(mdfd, HOT_REMOVE_DISK, makedev(info->disk.major, + info->disk.minor)); + return rv; +} + int set_array_info(int mdfd, struct supertype *st, struct mdinfo *info) { /* Initialise kernel's knowledge of array. @@ -1599,70 +1551,6 @@ unsigned long long min_recovery_start(struct mdinfo *array) return recovery_start; } -char *devnum2devname(int num) -{ - char name[100]; - if (num >= 0) - sprintf(name, "md%d", num); - else - sprintf(name, "md_d%d", -1-num); - return strdup(name); -} - -int devname2devnum(char *name) -{ - char *ep; - int num; - if (strncmp(name, "md_d", 4)==0) - num = -1-strtoul(name+4, &ep, 10); - else - num = strtoul(name+2, &ep, 10); - return num; -} - -int stat2devnum(struct stat *st) -{ - char path[30]; - char link[200]; - char *cp; - int n; - - if ((S_IFMT & st->st_mode) == S_IFBLK) { - if (major(st->st_rdev) == MD_MAJOR) - return minor(st->st_rdev); - else if (major(st->st_rdev) == get_mdp_major()) - return -1- (minor(st->st_rdev)>>MdpMinorShift); - - /* must be an extended-minor partition. Look at the - * /sys/dev/block/%d:%d link which must look like - * ../../block/mdXXX/mdXXXpYY - */ - sprintf(path, "/sys/dev/block/%d:%d", major(st->st_rdev), - minor(st->st_rdev)); - n = readlink(path, link, sizeof(link)-1); - if (n <= 0) - return NoMdDev; - link[n] = 0; - cp = strrchr(link, '/'); - if (cp) *cp = 0; - cp = strchr(link, '/'); - if (cp && strncmp(cp, "/md", 3) == 0) - return devname2devnum(cp+1); - } - return NoMdDev; - -} - -int fd2devnum(int fd) -{ - struct stat stb; - if (fstat(fd, &stb) == 0) - return stat2devnum(&stb); - return NoMdDev; -} - -char *pid_dir = VAR_RUN; - int mdmon_pid(int devnum) { char path[100]; @@ -1671,7 +1559,7 @@ int mdmon_pid(int devnum) int n; char *devname = devnum2devname(devnum); - sprintf(path, "%s/%s.pid", pid_dir, devname); + sprintf(path, "%s/%s.pid", MDMON_DIR, devname); free(devname); fd = open(path, O_RDONLY | O_NOATIME, 0); @@ -1697,7 +1585,7 @@ int mdmon_running(int devnum) int start_mdmon(int devnum) { - int i; + int i, skipped; int len; pid_t pid; int status; @@ -1712,7 +1600,7 @@ int start_mdmon(int devnum) 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; @@ -1728,15 +1616,27 @@ int start_mdmon(int devnum) 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 */ @@ -1800,11 +1700,12 @@ int flush_metadata_updates(struct supertype *st) 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; mu->space = NULL; + mu->space_list = NULL; mu->next = NULL; *st->update_tail = mu; st->update_tail = &mu->next; @@ -1816,3 +1717,114 @@ void append_metadata_update(struct supertype *st, void *buf, int len) unsigned int __invalid_size_argument_for_IOC = 0; #endif +int experimental(void) +{ + if (check_env("MDADM_EXPERIMENTAL")) + return 1; + else { + pr_err("To use this feature MDADM_EXPERIMENTAL" + " environment variable has to be defined.\n"); + return 0; + } +} + +/* Pick all spares matching given criteria from a container + * if min_size == 0 do not check size + * if domlist == NULL do not check domains + * if spare_group given add it to domains of each spare + * metadata allows to test domains using metadata of destination array */ +struct mdinfo *container_choose_spares(struct supertype *st, + unsigned long long min_size, + struct domainlist *domlist, + char *spare_group, + const char *metadata, int get_one) +{ + struct mdinfo *d, **dp, *disks = NULL; + + /* get list of all disks in container */ + if (st->ss->getinfo_super_disks) + disks = st->ss->getinfo_super_disks(st); + + if (!disks) + return disks; + /* find spare devices on the list */ + dp = &disks->devs; + disks->array.spare_disks = 0; + while (*dp) { + int found = 0; + d = *dp; + if (d->disk.state == 0) { + /* check if size is acceptable */ + unsigned long long dev_size; + dev_t dev = makedev(d->disk.major,d->disk.minor); + + if (!min_size || + (dev_size_from_id(dev, &dev_size) && + dev_size >= min_size)) + found = 1; + /* check if domain matches */ + if (found && domlist) { + struct dev_policy *pol = devnum_policy(dev); + if (spare_group) + pol_add(&pol, pol_domain, + spare_group, NULL); + if (domain_test(domlist, pol, metadata) != 1) + found = 0; + dev_policy_free(pol); + } + } + if (found) { + dp = &d->next; + disks->array.spare_disks++; + if (get_one) { + sysfs_free(*dp); + d->next = NULL; + } + } else { + *dp = d->next; + d->next = NULL; + sysfs_free(d); + } + } + 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))); +}