/*
* mdadm - manage Linux "md" devices aka RAID arrays.
*
- * Copyright (C) 2001-2009 Neil Brown <neilb@suse.de>
+ * Copyright (C) 2001-2012 Neil Brown <neilb@suse.de>
*
*
* This program is free software; you can redistribute it and/or modify
* Email: <neilb@suse.de>
*/
-#include "mdadm.h"
+#include "mdadm.h"
#include "md_u.h"
#include "md_p.h"
#include <ctype.h>
return layout;
}
-
int Create(struct supertype *st, char *mddev,
char *name, int *uuid,
int subdevs, struct mddev_dev *devlist,
/* now set some defaults */
-
if (s->layout == UnSet) {
do_default_layout = 1;
s->layout = default_layout(st, s->level, c->verbose);
mdi = sysfs_read(-1, dnum, GET_VERSION);
pr_err("Creating array inside "
- "%s container %s\n",
+ "%s container %s\n",
mdi?mdi->text_version:"managed", path);
sysfs_free(mdi);
} else
s->bitmap_file = NULL;
}
-
sysfs_init(&info, mdfd, 0);
if (st->ss->external && st->container_dev != NoMdDev) {
/*
* mdadm - manage Linux "md" devices aka RAID arrays.
*
- * Copyright (C) 2001-2009 Neil Brown <neilb@suse.de>
+ * Copyright (C) 2001-2012 Neil Brown <neilb@suse.de>
*
*
* This program is free software; you can redistribute it and/or modify
printf("MD_METADATA=%d.%d\n",
array.major_version, array.minor_version);
}
-
+
if (st && st->sb && info) {
char nbuf[64];
struct map_ent *mp, *map = NULL;
}
disks = xmalloc(max_disks * sizeof(mdu_disk_info_t));
- for (d=0; d<max_disks; d++) {
+ for (d = 0; d < max_disks; d++) {
disks[d].state = (1<<MD_DISK_REMOVED);
disks[d].major = disks[d].minor = 0;
disks[d].number = disks[d].raid_disk = d;
}
next = array.raid_disks;
- for (d=0; d < max_disks; d++) {
+ for (d = 0; d < max_disks; d++) {
mdu_disk_info_t disk;
disk.number = d;
if (ioctl(fd, GET_DISK_INFO, &disk) < 0) {
str = "container";
printf(" Raid Level : %s\n", str?str:"-unknown-");
if (larray_size)
- printf(" Array Size : %llu%s\n", (larray_size>>10), human_size(larray_size));
+ printf(" Array Size : %llu%s\n", (larray_size>>10),
+ human_size(larray_size));
if (array.level >= 1) {
if (array.major_version != 0 &&
(larray_size >= 0xFFFFFFFFULL|| array.size == 0)) {
if (array.raid_disks)
printf(" Raid Devices : %d\n", array.raid_disks);
printf(" Total Devices : %d\n", array.nr_disks);
- if (!container &&
+ if (!container &&
((sra == NULL && array.major_version == 0) ||
(sra && sra->array.major_version == 0)))
printf("Preferred Minor : %d\n", array.md_minor);
if (atime)
printf(" Update Time : %.24s\n", ctime(&atime));
if (array.raid_disks) {
- static char *sync_action[] = {", recovering",", resyncing",", reshaping",", checking"};
+ static char *sync_action[] = {
+ ", recovering", ", resyncing",
+ ", reshaping", ", checking" };
char *st;
if (avail_disks == array.raid_disks)
st = "";
}
if (e && e->percent >= 0) {
- static char *sync_action[] = {"Rebuild", "Resync", "Reshape", "Check"};
+ static char *sync_action[] = {
+ "Rebuild", "Resync",
+ "Reshape", "Check"};
printf(" %7s Status : %d%% complete\n", sync_action[e->resync], e->percent);
is_rebuilding = 1;
}
#endif
if (info->delta_disks != 0)
printf(" Delta Devices : %d, (%d->%d)\n",
- info->delta_disks, array.raid_disks - info->delta_disks, array.raid_disks);
+ info->delta_disks,
+ array.raid_disks - info->delta_disks,
+ array.raid_disks);
if (info->new_level != array.level) {
str = map_num(pers, info->new_level);
printf(" New Level : %s\n", str?str:"-unknown-");
if (c->test && d < array.raid_disks
&& !(disk.state & (1<<MD_DISK_SYNC)))
rv |= 1;
- if ((dv=map_dev_preferred(disk.major, disk.minor, 0, c->prefer))) {
+ dv=map_dev_preferred(disk.major, disk.minor, 0, c->prefer);
+ if (dv != NULL) {
if (c->brief) {
if (devices) {
devices = xrealloc(devices,
/*
* mdadm - manage Linux "md" devices aka RAID arrays.
*
- * Copyright (C) 2001-2009 Neil Brown <neilb@suse.de>
+ * Copyright (C) 2001-2012 Neil Brown <neilb@suse.de>
*
*
* This program is free software; you can redistribute it and/or modify
*
* utime, state etc
*
- * If (brief) gather devices for same array and just print a mdadm.conf line including devices=
+ * If (brief) gather devices for same array and just print a mdadm.conf
+ * line including devices=
* if devlist==NULL, use conf_get_devs()
*/
int fd;
int spares;
} *arrays = NULL;
- for (; devlist ; devlist=devlist->next) {
+ for (; devlist ; devlist = devlist->next) {
struct supertype *st;
int have_container = 0;
} else if (c->brief) {
struct array *ap;
char *d;
- for (ap=arrays; ap; ap=ap->next) {
+ for (ap = arrays; ap; ap = ap->next) {
if (st->ss == ap->st->ss &&
- st->ss->compare_super(ap->st, st)==0)
+ st->ss->compare_super(ap->st, st) == 0)
break;
}
if (!ap) {
}
if (c->brief) {
struct array *ap;
- for (ap=arrays; ap; ap=ap->next) {
+ for (ap = arrays; ap; ap = ap->next) {
char sep='=';
char *d;
int newline = 0;
newline += printf(" spares=%d", ap->spares);
if (c->verbose > 0) {
newline += printf(" devices");
- for (d=dl_next(ap->devs); d!= ap->devs; d=dl_next(d)) {
+ for (d = dl_next(ap->devs);
+ d != ap->devs;
+ d=dl_next(d)) {
printf("%c%s", sep, d);
sep=',';
}
/*
* mdadm - manage Linux "md" devices aka RAID arrays.
*
- * Copyright (C) 2001-2009 Neil Brown <neilb@suse.de>
+ * Copyright (C) 2001-2012 Neil Brown <neilb@suse.de>
*
*
* This program is free software; you can redistribute it and/or modify
st = super_by_fd(fd, &subarray);
if (!st) {
- pr_err("cannot handle arrays with superblock version %d\n", info.array.major_version);
+ pr_err("cannot handle arrays with superblock version %d\n",
+ info.array.major_version);
return 1;
}
free(st);
return 1;
}
- /* now check out all the devices and make sure we can read the superblock */
+ /* now check out all the devices and make sure we can read the
+ * superblock */
for (d=0 ; d < info.array.raid_disks ; d++) {
mdu_disk_info_t disk;
char *dv;
)
st->ss->write_bitmap(st, fd2);
else {
- pr_err("failed "
- "to create internal bitmap - chunksize problem.\n");
+ pr_err("failed to create internal bitmap"
+ " - chunksize problem.\n");
close(fd2);
return 1;
}
int max_devs = st->max_devs;
/* try to load a superblock */
- for (d=0; d<max_devs; d++) {
+ for (d = 0; d < max_devs; d++) {
mdu_disk_info_t disk;
char *dv;
int fd2;
(disk.state & (1<<MD_DISK_REMOVED)))
continue;
dv = map_dev(disk.major, disk.minor, 1);
- if (!dv) continue;
+ if (!dv)
+ continue;
fd2 = dev_open(dv, O_RDONLY);
if (fd2 >= 0) {
if (st->ss->load_super(st, fd2, NULL) == 0) {
{
int i;
int csum = 0;
- for (i=0; i<len; i++)
+ for (i = 0; i < len; i++)
csum = (csum<<3) + buf[0];
return __cpu_to_le32(csum);
}
switch (re->level) {
case 4:
- re->after.layout = 0 ; break;
+ re->after.layout = 0;
+ break;
case 5:
- re->after.layout = ALGORITHM_PARITY_N; break;
+ re->after.layout = ALGORITHM_PARITY_N;
+ break;
}
break;
switch (re->level) {
case 4:
- re->after.layout = 0 ; break;
+ re->after.layout = 0;
+ break;
case 5:
- re->after.layout = ALGORITHM_PARITY_N; break;
+ re->after.layout = ALGORITHM_PARITY_N;
+ break;
}
break;
+ info->delta_disks
- delta_parity);
switch (re->level) {
- case 6: re->parity = 2; break;
+ case 6: re->parity = 2;
+ break;
case 4:
- case 5: re->parity = 1; break;
- default: re->parity = 0; break;
+ case 5: re->parity = 1;
+ break;
+ default: re->parity = 0;
+ break;
}
/* So we have a restripe operation, we need to calculate the number
* of blocks per reshape operation.
}
}
for (j=0; j<info->array.raid_disks; j++) {
- if (fdlist[j] < 0) continue;
+ if (fdlist[j] < 0)
+ continue;
if (st->ss->load_super(st, fdlist[j], NULL))
continue;
st->ss->getinfo_super(st, &dinfo, NULL);
* Incremental.c - support --incremental. Part of:
* mdadm - manage Linux "md" devices aka RAID arrays.
*
- * Copyright (C) 2006-2009 Neil Brown <neilb@suse.de>
+ * Copyright (C) 2006-2012 Neil Brown <neilb@suse.de>
*
*
* This program is free software; you can redistribute it and/or modify
else
trustworthy = FOREIGN;
-
if (!match && !conf_test_metadata(st->ss->name, policy,
(trustworthy == LOCAL))) {
if (c->verbose >= 1)
}
sra = sysfs_read(mdfd, -1, (GET_DEVS | GET_STATE |
GET_OFFSET | GET_SIZE));
-
+
if (!sra || !sra->devs || sra->devs->disk.raid_disk >= 0) {
/* It really should be 'none' - must be old buggy
* kernel, and mdadm -I may not be able to complete.
sra = sysfs_read(mdfd, -1, (GET_DEVS | GET_STATE |
GET_OFFSET | GET_SIZE));
-
+
if (mp->path)
strcpy(chosen_name, mp->path);
else
info.array.working_disks = 0;
for (d = sra->devs; d; d=d->next)
info.array.working_disks ++;
-
+
}
/* 7/ Is there enough devices to possibly start the array? */
if (c->verbose >= 0)
pr_err("container %s now has %d device%s\n",
chosen_name, info.array.working_disks,
- info.array.working_disks==1?"":"s");
+ info.array.working_disks == 1?"":"s");
wait_for(chosen_name, mdfd);
if (st->ss->external)
devnum = fd2devnum(mdfd);
for (d = sra->devs ; d ; d = d->next)
numdevs++;
- for (d = sra->devs, devnum=0 ; d ; d = d->next, devnum++) {
+ for (d = sra->devs, devnum = 0 ; d ; d = d->next, devnum++) {
char dn[30];
int dfd;
int ok;
else if (info.events == max_events+1) {
int i;
max_events = info.events;
- for (i=0; i < raid_disks; i++)
+ for (i = 0; i < raid_disks; i++)
if (avail[i])
avail[i]--;
avail[info.disk.raid_disk] = 2;
if (st == NULL) {
int i;
st2 = NULL;
- for(i=0; !st2 && superlist[i]; i++)
+ for(i = 0; !st2 && superlist[i]; i++)
st2 = superlist[i]->match_metadata_desc(
sra->text_version);
if (!st2) {
} else {
int uuid[4];
struct map_ent *mp, *map = NULL;
-
+
if (!parse_uuid(devname, uuid))
return mdname;
mp = map_by_uuid(&map, uuid);
{
int i, num = 0;
- for (i=0; i < num_bits / 8; i++)
+ for (i = 0; i < num_bits / 8; i++)
num += count_dirty_bits_byte(buf[i], 8);
if (num_bits % 8) /* not an even byte boundary */
return (bits + bits_per_sector - 1) / bits_per_sector;
}
-
bitmap_info_t *bitmap_fd_read(int fd, int brief)
{
/* Note: fd might be open O_DIRECT, so we must be
/*
* mdadm - manage Linux "md" devices aka RAID arrays.
*
- * Copyright (C) 2001-2009 Neil Brown <neilb@suse.de>
+ * Copyright (C) 2001-2012 Neil Brown <neilb@suse.de>
*
*
* This program is free software; you can redistribute it and/or modify
#include "md_p.h"
#include <ctype.h>
-
void make_parts(char *dev, int cnt)
{
/* make 'cnt' partition devices for 'dev'
char sym[1024];
int err;
- if (cnt==0) cnt=4;
+ if (cnt == 0)
+ cnt = 4;
if (lstat(dev, &stb)!= 0)
return;
} else
return;
name = xmalloc(nlen);
- for (i=1; i <= cnt ; i++) {
+ for (i = 1; i <= cnt ; i++) {
struct stat stb2;
snprintf(name, nlen, "%s%s%d", dev, dig?"p":"", i);
- if (stat(name, &stb2)==0) {
+ if (stat(name, &stb2) == 0) {
if (!S_ISBLK(stb2.st_mode) || !S_ISBLK(stb.st_mode))
continue;
if (stb2.st_rdev == makedev(major_num, minor_num+i))
free(name);
}
-
/*
* We need a new md device to assemble/build/create an array.
* 'dev' is a name given us by the user (command line or mdadm.conf)
* supported by 'dev', we add a "_%d" suffix based on the minor number
* use that.
*
- * If udev is configured, we create a temporary device, open it, and
+ * If udev is configured, we create a temporary device, open it, and
* unlink it.
* If not, we create the /dev/mdXX device, and is name is usable,
* /dev/md/name
if (chosen == NULL)
chosen = cbuf;
-
if (autof == 0)
autof = ci->autof;
strcpy(chosen, "/dev/md/");
cname = chosen + strlen(chosen);
-
if (dev) {
if (strncmp(dev, "/dev/md/", 8) == 0) {
strcpy(cname, dev+8);
use_mdp = 0;
}
if (num < 0 && trustworthy == LOCAL && name) {
- /* if name is numeric, possibly prefixed by
+ /* if name is numeric, possibly prefixed by
* 'md' or '/dev/md', use that for num
* if it is not already in use */
char *ep;
if (trustworthy == METADATA && !isdigit(cname[cnlen-1]))
sprintf(cname+cnlen, "%d", unum);
else
- /* add _%d to FOREIGN array that don't
+ /* add _%d to FOREIGN array that don't
* a 'host:' prefix
*/
sprintf(cname+cnlen, "_%d", unum);
}
if (use_mdp == 1)
make_parts(devname, parts);
- if (strcmp(chosen, devname) != 0) {
- if (mkdir("/dev/md",0700)==0) {
+ if (strcmp(chosen, devname) != 0) {
+ if (mkdir("/dev/md",0700) == 0) {
if (chown("/dev/md", ci->uid, ci->gid))
perror("chown /dev/md");
if (chmod("/dev/md", ci->mode| ((ci->mode>>2) & 0111)))
return mdfd;
}
-
/* Open this and check that it is an md device.
* On success, return filedescriptor.
* On failure, return -1 if it doesn't exist,
/*
* mdadm - manage Linux "md" devices aka RAID arrays.
*
- * Copyright (C) 2001-2009 Neil Brown <neilb@suse.de>
+ * Copyright (C) 2001-2012 Neil Brown <neilb@suse.de>
*
*
* This program is free software; you can redistribute it and/or modify
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;
return 0;
}
-
/*
* Get the md version number.
* We use the RAID_VERSION ioctl if it is supported
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
}
* 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;
while (n--) {
if (avail[first])
cnt++;
array.raid_disks <= 0)
return 0;
avail = xcalloc(array.raid_disks, 1);
- for (i=0; i < MAX_DISKS && array.nr_disks > 0; i++) {
+ for (i = 0; i < MAX_DISKS && array.nr_disks > 0; i++) {
disk.number = i;
if (ioctl(fd, GET_DISK_INFO, &disk) != 0)
continue;
return rv;
}
-
const int uuid_zero[4] = { 0, 0, 0, 0 };
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] ||
return 0;
}
}
+
void copy_uuid(void *a, int b[4], int swapuuid)
{
if (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];
return 0;
if (read(fd, sb, 1024) != 1024)
return 0;
- if (strncmp((char*)sb+52, "ReIsErFs",8)!=0 &&
- strncmp((char*)sb+52, "ReIsEr2Fs",9)!=0)
+ if (strncmp((char*)sb+52, "ReIsErFs",8) != 0 &&
+ strncmp((char*)sb+52, "ReIsEr2Fs",9) != 0)
return 0;
pr_err("%s appears to contain a reiserfs file system\n",name);
size = sb[0]|(sb[1]|(sb[2]|sb[3]<<8)<<8)<<8;
{
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);
* 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)
unsigned int csum;
unsigned int *superc = (unsigned int*) super;
- for(i=0; i<bytes/4; i++)
- newcsum+= superc[i];
+ for(i = 0; i < bytes/4; i++)
+ newcsum += superc[i];
csum = (newcsum& 0xffffffff) + (newcsum>>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);
*/
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;
{
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;
}
void put_md_name(char *name)
{
- if (strncmp(name, "/dev/.tmp.md", 12)==0)
+ if (strncmp(name, "/dev/.tmp.md", 12) == 0)
unlink(name);
}
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) {
+ 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) {
+ if (mknod(devname, S_IFBLK|0600, makedev(major, minor)) == 0) {
fd = open(devname, flags);
unlink(devname);
}
int flags = O_RDWR;
sprintf(buf, "%d:%d", dev2major(devnum), dev2minor(devnum));
- for (i=0 ; i<25 ; i++) {
+ for (i = 0 ; i < 25 ; i++) {
int fd = dev_open(buf, flags|O_EXCL);
if (fd >= 0)
return fd;
(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 &&
st = xcalloc(1, sizeof(*st));
st->container_dev = NoMdDev;
- 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)
part = (struct GPT_part_entry *)buf;
- for (part_nr=0; part_nr < all_partitions; part_nr++) {
+ 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;
/* 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);
{
int i, skipped;
int len;
- pid_t pid;
+ pid_t pid;
int status;
char pathbuf[1024];
char *paths[4] = {
case 0:
/* FIXME yuk. CLOSE_EXEC?? */
skipped = 0;
- for (i=3; skipped < 20; i++)
+ for (i = 3; skipped < 20; i++)
if (close(i) < 0)
skipped++;
else
skipped = 0;
- for (i=0; paths[i]; i++)
+ for (i = 0; paths[i]; i++)
if (paths[i][0]) {
if (__offroot) {
execl(paths[i], "mdmon", "--offroot",
projects / thirdparty / mdadm.git / commitdiff
