X-Git-Url: http://git.ipfire.org/?p=thirdparty%2Fmdadm.git;a=blobdiff_plain;f=util.c;h=aa2c8be87dfbf17763633513e6087052b72bc9e8;hp=cc6ccb4d25f99ae737ce65996cd3d1c71d80477a;hb=4389b648bb9dc8ab61ce8777654d59634dafc737;hpb=53ed6ac36ef96e2327564b29ae06e3cc2820ba8f diff --git a/util.c b/util.c index cc6ccb4d..aa2c8be8 100644 --- a/util.c +++ b/util.c @@ -1,7 +1,7 @@ /* * mdadm - manage Linux "md" devices aka RAID arrays. * - * Copyright (C) 2001-2009 Neil Brown + * Copyright (C) 2001-2012 Neil Brown * * * This program is free software; you can redistribute it and/or modify @@ -28,6 +28,9 @@ #include #include #include +#include +#include +#include #include #include #include @@ -41,10 +44,10 @@ /* The argument structure */ struct blkpg_ioctl_arg { - int op; - int flags; - int datalen; - void *data; + int op; + int flags; + int datalen; + void *data; }; /* The subfunctions (for the op field) */ @@ -87,15 +90,16 @@ int parse_uuid(char *str, int uuid[4]) int hit = 0; /* number of Hex digIT */ int i; char c; - for (i=0; i<4; i++) uuid[i]=0; + for (i = 0; i < 4; i++) + uuid[i] = 0; - while ((c= *str++)) { + while ((c = *str++) != 0) { int n; - if (c>='0' && c<='9') + if (c >= '0' && c <= '9') n = c-'0'; - else if (c>='a' && c <= 'f') + else if (c >= 'a' && c <= 'f') n = 10 + c - 'a'; - else if (c>='A' && c <= 'F') + else if (c >= 'A' && c <= 'F') n = 10 + c - 'A'; else if (strchr(":. -", c)) continue; @@ -112,7 +116,6 @@ int parse_uuid(char *str, int uuid[4]) return 0; } - /* * Get the md version number. * We use the RAID_VERSION ioctl if it is supported @@ -125,37 +128,37 @@ int parse_uuid(char *str, int uuid[4]) int md_get_version(int fd) { - struct stat stb; - mdu_version_t vers; + struct stat stb; + mdu_version_t vers; - if (fstat(fd, &stb)<0) - return -1; - if ((S_IFMT&stb.st_mode) != S_IFBLK) - return -1; + if (fstat(fd, &stb)<0) + return -1; + if ((S_IFMT&stb.st_mode) != S_IFBLK) + return -1; - if (ioctl(fd, RAID_VERSION, &vers) == 0) - return (vers.major*10000) + (vers.minor*100) + vers.patchlevel; - if (errno == EACCES) - return -1; - if (major(stb.st_rdev) == MD_MAJOR) - return (3600); - return -1; + if (ioctl(fd, RAID_VERSION, &vers) == 0) + return (vers.major*10000) + (vers.minor*100) + vers.patchlevel; + if (errno == EACCES) + return -1; + if (major(stb.st_rdev) == MD_MAJOR) + return (3600); + return -1; } 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; } @@ -186,12 +189,13 @@ int mdadm_version(char *version) return (a*1000000)+(b*1000)+c; } -long long parse_size(char *size) +unsigned 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) + * INVALID_SECTORS returned on error. */ char *c; long long s = strtoll(size, &c, 10); @@ -210,10 +214,14 @@ long long parse_size(char *size) c++; s *= 1024 * 1024 * 2; break; + case 's': /* sectors */ + c++; + break; } - } + } else + s = INVALID_SECTORS; if (*c) - s = 0; + s = INVALID_SECTORS; return s; } @@ -241,7 +249,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); @@ -250,6 +258,17 @@ int parse_layout_faulty(char *layout) return mode | (atoi(layout+ln)<< ModeShift); } + +long parse_num(char *num) +{ + /* Either return a valid number, or -1 */ + char *c; + long rv = strtol(num, &c, 10); + if (rv < 0 || *c || !num[0]) + return -1; + else + return rv; +} #endif void remove_partitions(int fd) @@ -266,7 +285,7 @@ void remove_partitions(int fd) a.datalen = sizeof(p); a.flags = 0; memset(a.data, 0, a.datalen); - for (p.pno=0; p.pno < 16; p.pno++) + for (p.pno = 0; p.pno < 16; p.pno++) ioctl(fd, BLKPG, &a); #endif } @@ -309,29 +328,35 @@ int test_partition_from_id(dev_t id) 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 * which actual disks are present. */ copies = (layout&255)* ((layout>>8) & 255); - first=0; + first = 0; do { /* there must be one of the 'copies' form 'first' */ int n = copies; - int cnt=0; + int cnt = 0; + int this = first; while (n--) { - if (avail[first]) + if (avail[this]) cnt++; - first = (first+1) % raid_disks; + this = (this+1) % raid_disks; } if (cnt == 0) return 0; - + first = (first+(layout&255)) % raid_disks; } while (first != 0); return 1; @@ -363,17 +388,21 @@ int enough_fd(int fd) 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 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) @@ -382,12 +411,12 @@ int enough_fd(int fd) 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; } - const int uuid_zero[4] = { 0, 0, 0, 0 }; int same_uuid(int a[4], int b[4], int swapuuid) @@ -400,7 +429,7 @@ int same_uuid(int a[4], int b[4], int swapuuid) unsigned char *ac = (unsigned char *)a; unsigned char *bc = (unsigned char *)b; int i; - for (i=0; i<16; i+= 4) { + for (i = 0; i < 16; i += 4) { if (ac[i+0] != bc[i+3] || ac[i+1] != bc[i+2] || ac[i+2] != bc[i+1] || @@ -417,6 +446,7 @@ int same_uuid(int a[4], int b[4], int swapuuid) return 0; } } + void copy_uuid(void *a, int b[4], int swapuuid) { if (swapuuid) { @@ -427,7 +457,7 @@ void copy_uuid(void *a, int b[4], int swapuuid) unsigned char *ac = (unsigned char *)a; unsigned char *bc = (unsigned char *)b; int i; - for (i=0; i<16; i+= 4) { + for (i = 0; i < 16; i += 4) { ac[i+0] = bc[i+3]; ac[i+1] = bc[i+2]; ac[i+2] = bc[i+1]; @@ -492,9 +522,9 @@ 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", + cont_err("size=%dK mtime=%s", size*(1<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); crtime = info.array.ctime; level = map_num(pers, info.array.level); if (!level) level = "-unknown-"; - fprintf(stderr, " level=%s devices=%d ctime=%s", - level, info.array.raid_disks, ctime(&crtime)); + cont_err("level=%s devices=%d ctime=%s", + level, info.array.raid_disks, ctime(&crtime)); return 1; } @@ -549,7 +580,7 @@ int ask(char *mesg) { char *add = ""; int i; - for (i=0; i<5; i++) { + for (i = 0; i < 5; i++) { char buf[100]; fprintf(stderr, "%s%s", mesg, add); fflush(stderr); @@ -561,32 +592,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. @@ -597,18 +607,18 @@ int is_standard(char *dev, int *nump) * 0 if not a standard name. */ char *d = strrchr(dev, '/'); - int type=0; + int type = 0; int num; if (!d) return 0; - if (strncmp(d, "/d",2)==0) - d += 2, type=1; /* /dev/md/dN{pM} */ - else if (strncmp(d, "/md_d", 5)==0) - d += 5, type=1; /* /dev/md_dN{pM} */ - else if (strncmp(d, "/md", 3)==0) - d += 3, type=-1; /* /dev/mdN */ - else if (d-dev > 3 && strncmp(d-2, "md/", 3)==0) - d += 1, type=-1; /* /dev/md/N */ + if (strncmp(d, "/d",2) == 0) + d += 2, type = 1; /* /dev/md/dN{pM} */ + else if (strncmp(d, "/md_d", 5) == 0) + d += 5, type = 1; /* /dev/md_dN{pM} */ + else if (strncmp(d, "/md", 3) == 0) + d += 3, type = -1; /* /dev/mdN */ + else if (d-dev > 3 && strncmp(d-2, "md/", 3) == 0) + d += 1, type = -1; /* /dev/md/N */ else return 0; if (!*d) @@ -623,122 +633,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; @@ -746,13 +640,13 @@ unsigned long calc_csum(void *super, int bytes) unsigned int csum; unsigned int *superc = (unsigned int*) super; - for(i=0; i>32); #ifdef __alpha__ /* The in-kernel checksum calculation is always 16bit on * the alpha, though it is 32 bit on i386... - * I wonder what it is elsewhere... (it uses and API in + * I wonder what it is elsewhere... (it uses an API in * a way that it shouldn't). */ csum = (csum & 0xffff) + (csum >> 16); @@ -772,11 +666,11 @@ 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) - buf[0]=0; + buf[0] = 0; else if (bytes < 2*1024LL*1024LL*1024LL) { long cMiB = (bytes / ( (1LL<<20) / 200LL ) +1) /2; long cMB = (bytes / ( 1000000LL / 200LL ) +1) /2; @@ -793,24 +687,49 @@ char *human_size(long long bytes) return buf; } -char *human_size_brief(long long bytes) +char *human_size_brief(long long bytes, int prefix) { static char buf[30]; + /* We convert bytes to either centi-M{ega,ibi}bytes or + * centi-G{igi,ibi}bytes, with appropriate rounding, + * and then print 1/100th of those as a decimal. + * We allow upto 2048Megabytes before converting to + * gigabytes, as that shows more precision and isn't + * too large a number. + * Terabytes are not yet handled. + * + * If prefix == IEC, we mean prefixes like kibi,mebi,gibi etc. + * If prefix == JEDEC, we mean prefixes like kilo,mega,giga etc. + */ + if (bytes < 5000*1024) - snprintf(buf, sizeof(buf), "%ld.%02ldKiB", - (long)(bytes>>10), (long)(((bytes&1023)*100+512)/1024) - ); - else if (bytes < 2*1024LL*1024LL*1024LL) - snprintf(buf, sizeof(buf), "%ld.%02ldMiB", - (long)(bytes>>20), - (long)((bytes&0xfffff)+0x100000/200)/(0x100000/100) - ); + buf[0] = 0; + else if (prefix == IEC) { + if (bytes < 2*1024LL*1024LL*1024LL) { + long cMiB = (bytes / ( (1LL<<20) / 200LL ) +1) /2; + snprintf(buf, sizeof(buf), "%ld.%02ldMiB", + cMiB/100 , cMiB % 100); + } else { + long cGiB = (bytes / ( (1LL<<30) / 200LL ) +1) /2; + snprintf(buf, sizeof(buf), "%ld.%02ldGiB", + cGiB/100 , cGiB % 100); + } + } + else if (prefix == JEDEC) { + if (bytes < 2*1024LL*1024LL*1024LL) { + long cMB = (bytes / ( 1000000LL / 200LL ) +1) /2; + snprintf(buf, sizeof(buf), "%ld.%02ldMB", + cMB/100, cMB % 100); + } else { + long cGB = (bytes / (1000000000LL/200LL ) +1) /2; + snprintf(buf, sizeof(buf), "%ld.%02ldGB", + cGB/100 , cGB % 100); + } + } else - snprintf(buf, sizeof(buf), "%ld.%02ldGiB", - (long)(bytes>>30), - (long)(((bytes>>10)&0xfffff)+0x100000/200)/(0x100000/100) - ); + buf[0] = 0; + return buf; } @@ -834,86 +753,106 @@ 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) { - case 0: data_disks = raid_disks; break; - case 1: data_disks = 1; break; + case 0: data_disks = raid_disks; + break; + case 1: data_disks = 1; + break; case 4: - case 5: data_disks = raid_disks - 1; break; - case 6: data_disks = raid_disks - 2; break; + case 5: data_disks = raid_disks - 1; + break; + case 6: data_disks = raid_disks - 2; + break; 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; } -int get_mdp_major(void) +int devnm2devid(char *devnm) { -static int mdp_major = -1; - FILE *fl; - char *w; - int have_block = 0; - int have_devices = 0; - int last_num = -1; + /* First look in /sys/block/$DEVNM/dev for %d:%d + * If that fails, try parsing out a number + */ + char path[100]; + char *ep; + int fd; + int mjr,mnr; - 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); + sprintf(path, "/sys/block/%s/dev", devnm); + fd = open(path, O_RDONLY); + if (fd >= 0) { + char buf[20]; + int n = read(fd, buf, sizeof(buf)); + close(fd); + if (n > 0) + buf[n] = 0; + if (n > 0 && sscanf(buf, "%d:%d\n", &mjr, &mnr) == 2) + return makedev(mjr, mnr); } - fclose(fl); - return mdp_major; + if (strncmp(devnm, "md_d", 4) == 0 && + isdigit(devnm[4]) && + (mnr = strtoul(devnm+4, &ep, 10)) >= 0 && + ep > devnm && *ep == 0) + return makedev(get_mdp_major(), mnr << MdpMinorShift); + + if (strncmp(devnm, "md", 2) == 0 && + isdigit(devnm[2]) && + (mnr = strtoul(devnm+2, &ep, 10)) >= 0 && + ep > devnm && *ep == 0) + return makedev(MD_MAJOR, mnr); + + return 0; } #if !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO) -char *get_md_name(int dev) +char *get_md_name(char *devnm) { /* find /dev/md%d or /dev/md/%d or make a device /dev/.tmp.md%d */ /* if dev < 0, want /dev/md/d%d or find mdp in /proc/devices ... */ + static char devname[50]; struct stat stb; - dev_t rdev; + dev_t rdev = devnm2devid(devnm); char *dn; - if (dev < 0) { - int mdp = get_mdp_major(); - if (mdp < 0) return NULL; - rdev = makedev(mdp, (-1-dev)<<6); - snprintf(devname, sizeof(devname), "/dev/md/d%d", -1-dev); - if (stat(devname, &stb) == 0 - && (S_IFMT&stb.st_mode) == S_IFBLK - && (stb.st_rdev == rdev)) - return devname; - } else { - rdev = makedev(MD_MAJOR, dev); - snprintf(devname, sizeof(devname), "/dev/md%d", dev); - if (stat(devname, &stb) == 0 - && (S_IFMT&stb.st_mode) == S_IFBLK - && (stb.st_rdev == rdev)) - return devname; - - snprintf(devname, sizeof(devname), "/dev/md/%d", dev); + if (rdev == 0) + return 0; + if (strncmp(devnm, "md_", 3) == 0) { + snprintf(devname, sizeof(devname), "/dev/md/%s", + devnm + 3); if (stat(devname, &stb) == 0 && (S_IFMT&stb.st_mode) == S_IFBLK && (stb.st_rdev == rdev)) return devname; } + snprintf(devname, sizeof(devname), "/dev/%s", devnm); + if (stat(devname, &stb) == 0 + && (S_IFMT&stb.st_mode) == S_IFBLK + && (stb.st_rdev == rdev)) + return devname; + + snprintf(devname, sizeof(devname), "/dev/md/%s", devnm+2); + if (stat(devname, &stb) == 0 + && (S_IFMT&stb.st_mode) == S_IFBLK + && (stb.st_rdev == rdev)) + return devname; + dn = map_dev(major(rdev), minor(rdev), 0); if (dn) return dn; - snprintf(devname, sizeof(devname), "/dev/.tmp.md%d", dev); + snprintf(devname, sizeof(devname), "/dev/.tmp.%s", devnm); if (mknod(devname, S_IFBLK | 0600, rdev) == -1) if (errno != EEXIST) return NULL; @@ -928,32 +867,9 @@ char *get_md_name(int dev) void put_md_name(char *name) { - if (strncmp(name, "/dev/.tmp.md", 12)==0) + if (strncmp(name, "/dev/.tmp.md", 12) == 0) unlink(name); } - -int find_free_devnum(int use_partitions) -{ - int devnum; - for (devnum = 127; devnum != 128; - devnum = devnum ? devnum-1 : (1<<20)-1) { - char *dn; - int _devnum; - - _devnum = use_partitions ? (-1-devnum) : devnum; - if (mddev_busy(_devnum)) - continue; - /* make sure it is new to /dev too, at least as a - * non-standard */ - dn = map_dev(dev2major(_devnum), dev2minor(_devnum), 0); - if (dn && ! is_standard(dn, NULL)) - continue; - break; - } - if (devnum == 128) - return NoMdDev; - return use_partitions ? (-1-devnum) : devnum; -} #endif /* !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO) */ int dev_open(char *dev, int flags) @@ -974,21 +890,17 @@ int dev_open(char *dev, int flags) if (e > dev && *e == ':' && e[1] && (minor = strtoul(e+1, &e, 0)) >= 0 && *e == 0) { - 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); - } + 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) { + /* Try /tmp as /dev appear to be read-only */ snprintf(devname, sizeof(devname), "/tmp/.tmp.md.%d:%d:%d", (int)getpid(), major, minor); - if (mknod(devname, S_IFBLK|0600, makedev(major, minor))==0) { + if (mknod(devname, S_IFBLK|0600, makedev(major, minor)) == 0) { fd = open(devname, flags); unlink(devname); } @@ -998,27 +910,43 @@ int dev_open(char *dev, int flags) return fd; } -int open_dev(int devnum) +int open_dev_flags(char *devnm, int flags) { + int devid; char buf[20]; - sprintf(buf, "%d:%d", dev2major(devnum), dev2minor(devnum)); - return dev_open(buf, O_RDONLY); + devid = devnm2devid(devnm); + sprintf(buf, "%d:%d", major(devid), minor(devid)); + return dev_open(buf, flags); } -int open_dev_excl(int devnum) +int open_dev(char *devnm) +{ + return open_dev_flags(devnm, O_RDONLY); +} + +int open_dev_excl(char *devnm) { char buf[20]; int i; + int flags = O_RDWR; + int devid = devnm2devid(devnm); + long delay = 1000; - sprintf(buf, "%d:%d", dev2major(devnum), dev2minor(devnum)); - for (i=0 ; i<25 ; i++) { - int fd = dev_open(buf, O_RDWR|O_EXCL); + sprintf(buf, "%d:%d", major(devid), minor(devid)); + for (i = 0 ; i < 25 ; i++) { + 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); + usleep(delay); + if (delay < 200000) + delay *= 2; } return -1; } @@ -1041,18 +969,21 @@ void wait_for(char *dev, int fd) { int i; struct stat stb_want; + long delay = 1000; if (fstat(fd, &stb_want) != 0 || (stb_want.st_mode & S_IFMT) != S_IFBLK) return; - for (i=0 ; i<25 ; i++) { + for (i = 0 ; i < 25 ; i++) { struct stat stb; if (stat(dev, &stb) == 0 && (stb.st_mode & S_IFMT) == S_IFBLK && (stb.st_rdev == stb_want.st_rdev)) return; - usleep(200000); + usleep(delay); + if (delay < 200000) + delay *= 2; } if (i == 25) dprintf("%s: timeout waiting for %s\n", __func__, dev); @@ -1078,9 +1009,9 @@ struct supertype *super_by_fd(int fd, char **subarrayp) char version[20]; int i; char *subarray = NULL; - int container = NoMdDev; + char container[32] = ""; - sra = sysfs_read(fd, 0, GET_VERSION); + sra = sysfs_read(fd, NULL, GET_VERSION); if (sra) { vers = sra->array.major_version; @@ -1102,10 +1033,11 @@ struct supertype *super_by_fd(int fd, char **subarrayp) char *dev = verstr+1; subarray = strchr(dev, '/'); - if (subarray) + if (subarray) { *subarray++ = '\0'; - subarray = strdup(subarray); - container = devname2devnum(dev); + subarray = xstrdup(subarray); + } + strcpy(container, dev); if (sra) sysfs_free(sra); sra = sysfs_read(-1, container, GET_VERSION); @@ -1124,8 +1056,8 @@ struct supertype *super_by_fd(int fd, char **subarrayp) st->sb = NULL; if (subarrayp) *subarrayp = subarray; - st->container_dev = container; - st->devnum = fd2devnum(fd); + strcpy(st->container_devnm, container); + strcpy(st->devnm, fd2devnm(fd)); } else free(subarray); @@ -1156,13 +1088,12 @@ 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; + st->ignore_hw_compat = orig->ignore_hw_compat; + st->data_offset = orig->data_offset; st->sb = NULL; st->info = NULL; return st; @@ -1179,11 +1110,10 @@ struct supertype *guess_super_type(int fd, enum guess_types guess_type) int bestsuper = -1; int i; - st = malloc(sizeof(*st)); - memset(st, 0, sizeof(*st)); - st->container_dev = NoMdDev; + st = xcalloc(1, sizeof(*st)); + st->container_devnm[0] = 0; - for (i=0 ; superlist[i]; i++) { + for (i = 0 ; superlist[i]; i++) { int rv; ss = superlist[i]; if (guess_type == guess_array && ss->add_to_super == NULL) @@ -1191,6 +1121,7 @@ struct supertype *guess_super_type(int fd, enum guess_types guess_type) 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; @@ -1206,6 +1137,7 @@ struct supertype *guess_super_type(int fd, enum guess_types guess_type) 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); @@ -1235,7 +1167,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; } @@ -1267,9 +1199,9 @@ int must_be_container(int fd) 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; unsigned part_nr; @@ -1277,8 +1209,9 @@ static int get_gpt_last_partition_end(int fd, unsigned long long *endofpart) *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; @@ -1292,16 +1225,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; - for (part_nr=0; part_nr < all_partitions; part_nr++) { /* is this valid partition? */ if (memcmp(part->type_guid, empty_gpt_entry, 16) != 0) { /* check the last lba for the current partition */ @@ -1310,13 +1243,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; } @@ -1348,7 +1274,7 @@ static int get_last_partition_end(int fd, unsigned long long *endofpart) /* found the correct signature */ part = boot_sect.parts; - for (part_nr=0; part_nr < MBR_PARTITIONS; part_nr++) { + for (part_nr = 0; part_nr < MBR_PARTITIONS; part_nr++) { /* check for GPT type */ if (part->part_type == MBR_GPT_PARTITION_TYPE) { retval = get_gpt_last_partition_end(fd, endofpart); @@ -1383,37 +1309,25 @@ 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 */ - 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; } } return 0; } -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) - return; -} - int open_container(int fd) { /* 'fd' is a block device. Find out if it is in use @@ -1442,6 +1356,20 @@ int open_container(int fd) continue; if (de->d_name[0] == '.') continue; + /* Need to make sure it is a container and not a volume */ + sprintf(e, "/%s/md/metadata_version", de->d_name); + dfd = open(path, O_RDONLY); + if (dfd < 0) + continue; + n = read(dfd, buf, sizeof(buf)); + close(dfd); + if (n <= 0 || (unsigned)n >= sizeof(buf)) + continue; + buf[n] = 0; + if (strncmp(buf, "external", 8) != 0 || + n < 10 || + buf[9] == '/') + continue; sprintf(e, "/%s/dev", de->d_name); dfd = open(path, O_RDONLY); if (dfd < 0) @@ -1478,13 +1406,47 @@ struct superswitch *version_to_superswitch(char *vers) return NULL; } +int metadata_container_matches(char *metadata, char *devnm) +{ + /* Check if 'devnm' is the container named in 'metadata' + * which is + * /containername/componentname or + * -containername/componentname + */ + int l; + if (*metadata != '/' && *metadata != '-') + return 0; + l = strlen(devnm); + if (strncmp(metadata+1, devnm, l) != 0) + return 0; + if (metadata[l+1] != '/') + return 0; + return 1; +} + +int metadata_subdev_matches(char *metadata, char *devnm) +{ + /* Check if 'devnm' is the subdev named in 'metadata' + * which is + * /containername/subdev or + * -containername/subdev + */ + char *sl; + if (*metadata != '/' && *metadata != '-') + return 0; + sl = strchr(metadata+1, '/'); + if (!sl) + return 0; + if (strcmp(sl+1, devnm) == 0) + return 1; + return 0; +} + int is_container_member(struct mdstat_ent *mdstat, char *container) { if (mdstat->metadata_version == NULL || strncmp(mdstat->metadata_version, "external:", 9) != 0 || - !is_subarray(mdstat->metadata_version+9) || - strncmp(mdstat->metadata_version+10, container, strlen(container)) != 0 || - mdstat->metadata_version[10+strlen(container)] != '/') + !metadata_container_matches(mdstat->metadata_version+9, container)) return 0; return 1; @@ -1517,71 +1479,70 @@ int open_subarray(char *dev, char *subarray, struct supertype *st, int quiet) struct mdinfo *mdi; struct mdinfo *info; int fd, err = 1; + char *_devnm; 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) { + _devnm = fd2devnm(fd); + if (_devnm == NULL) { 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; } + strcpy(st->devnm, _devnm); - mdi = sysfs_read(fd, st->devnum, GET_VERSION|GET_LEVEL); + mdi = sysfs_read(fd, st->devnm, 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 (st->devnm[0] == 0) { 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); - goto free_name; + pr_err("%s is not a container\n", dev); + goto free_sysfs; } 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; + goto free_sysfs; } 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; } @@ -1592,9 +1553,6 @@ int open_subarray(char *dev, char *subarray, struct supertype *st, int quiet) free_super: if (err) st->ss->free_super(st); - free_name: - if (err) - free(st->devname); free_sysfs: sysfs_free(mdi); close_fd: @@ -1625,7 +1583,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; @@ -1692,83 +1650,14 @@ unsigned long long min_recovery_start(struct mdinfo *array) return recovery_start; } -void fmt_devname(char *name, int num) -{ - if (num >= 0) - sprintf(name, "md%d", num); - else - sprintf(name, "md_d%d", -1-num); -} - -char *devnum2devname(int num) -{ - char name[100]; - fmt_devname(name,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) == (unsigned)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 = strrchr(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; -} - -int mdmon_pid(int devnum) +int mdmon_pid(char *devnm) { char path[100]; char pid[10]; int fd; int n; - char *devname = devnum2devname(devnum); - sprintf(path, "%s/%s.pid", MDMON_DIR, devname); - free(devname); + sprintf(path, "%s/%s.pid", MDMON_DIR, devnm); fd = open(path, O_RDONLY | O_NOATIME, 0); @@ -1781,9 +1670,9 @@ int mdmon_pid(int devnum) return atoi(pid); } -int mdmon_running(int devnum) +int mdmon_running(char *devnm) { - int pid = mdmon_pid(devnum); + int pid = mdmon_pid(devnm); if (pid <= 0) return 0; if (kill(pid, 0) == 0) @@ -1791,11 +1680,11 @@ int mdmon_running(int devnum) return 0; } -int start_mdmon(int devnum) +int start_mdmon(char *devnm) { - int i; + int i, skipped; int len; - pid_t pid; + pid_t pid; int status; char pathbuf[1024]; char *paths[4] = { @@ -1808,7 +1697,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; @@ -1821,38 +1710,69 @@ int start_mdmon(int devnum) } else pathbuf[0] = '\0'; + /* First try to run systemctl */ + switch(fork()) { + case 0: + /* FIXME yuk. CLOSE_EXEC?? */ + skipped = 0; + for (i = 3; skipped < 20; i++) + if (close(i) < 0) + skipped++; + else + skipped = 0; + + /* Don't want to see error messages from systemctl. + * If the service doesn't exist, we start mdmon ourselves. + */ + close(2); + open("/dev/null", O_WRONLY); + snprintf(pathbuf, sizeof(pathbuf), "mdmon@%s.service", + devnm); + status = execl("/usr/bin/systemctl", "systemctl", "start", + pathbuf, NULL); + status = execl("/bin/systemctl", "systemctl", "start", + pathbuf, NULL); + exit(1); + case -1: pr_err("cannot run mdmon. " + "Array remains readonly\n"); + return -1; + default: /* parent - good */ + pid = wait(&status); + if (pid >= 0 && status == 0) + return 0; + } + + /* That failed, try running mdmon directly */ switch(fork()) { case 0: /* FIXME yuk. CLOSE_EXEC?? */ - for (i=3; i < 100; i++) - close(i); - for (i=0; paths[i]; i++) - if (paths[i][0]) + 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); + devnm, 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 */ pid = wait(&status); - if (pid < 0 || status != 0) + if (pid < 0 || status != 0) { + pr_err("failed to launch mdmon. " + "Array remains readonly\n"); return -1; + } } return 0; } -int check_env(char *name) -{ - char *val = getenv(name); - - if (val && atoi(val) == 1) - return 1; - - return 0; -} - __u32 random32(void) { __u32 rv; @@ -1873,7 +1793,7 @@ int flush_metadata_updates(struct supertype *st) return -1; } - sfd = connect_monitor(devnum2devname(st->container_dev)); + sfd = connect_monitor(st->container_devnm); if (sfd < 0) return -1; @@ -1896,7 +1816,7 @@ 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; @@ -1918,7 +1838,8 @@ int experimental(void) 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; } } @@ -1959,7 +1880,7 @@ struct mdinfo *container_choose_spares(struct supertype *st, found = 1; /* check if domain matches */ if (found && domlist) { - struct dev_policy *pol = devnum_policy(dev); + struct dev_policy *pol = devid_policy(dev); if (spare_group) pol_add(&pol, pol_domain, spare_group, NULL); @@ -1983,3 +1904,47 @@ struct mdinfo *container_choose_spares(struct supertype *st, } return disks; } + +/* Checks if paths point to the same device + * Returns 0 if they do. + * Returns 1 if they don't. + * Returns -1 if something went wrong, + * e.g. paths are empty or the files + * they point to don't exist */ +int compare_paths (char* path1, char* path2) +{ + struct stat st1,st2; + + if (path1 == NULL || path2 == NULL) + return -1; + if (stat(path1,&st1) != 0) + return -1; + if (stat(path2,&st2) != 0) + return -1; + if ((st1.st_ino == st2.st_ino) && (st1.st_dev == st2.st_dev)) + return 0; + return 1; +} + +/* Make sure we can open as many devices as needed */ +void enable_fds(int devices) +{ + unsigned int fds = 20 + devices; + struct rlimit lim; + if (getrlimit(RLIMIT_NOFILE, &lim) != 0 + || lim.rlim_cur >= fds) + return; + if (lim.rlim_max < fds) + lim.rlim_max = fds; + lim.rlim_cur = fds; + setrlimit(RLIMIT_NOFILE, &lim); +} + +int in_initrd(void) +{ + /* This is based on similar function in systemd. */ + struct statfs s; + return statfs("/", &s) >= 0 && + (s.f_type == TMPFS_MAGIC || + s.f_type == RAMFS_MAGIC); +}