Martchus
/
mdadm
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

mdadm-0.8.1

This commit is contained in:
Neil Brown 2002-04-05 22:00:28 +00:00
parent e0d1903663
commit c913b90e6d
14 changed files with 61 additions and 417 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
ChangeLog
View File

@ -1,4 +1,11 @@
Changes Prior to this release
- Add "INSTALL" file.
- Fix some "i" variables that were not being set properly
- Initialise minsize and maxsize so that compilers don't complain.
- Tidy up Makefile and mdadm.spec installations
- Add "multipath" to documentation of valid levels
Changes Prior to 0.8 release
- Fix another bug in Assemble.c due to confusing 'i' with 'j'
- Minimal, untested, support for multipath
- re-write of argument parsing to have more coherent modes,

19
Create.c
View File

@ -52,10 +52,10 @@ int Create(char *mddev, int mdfd,
* if runstop==run, or raiddisks diskswere used,
* RUN_ARRAY
*/
int minsize, maxsize;
int minsize=0, maxsize=0;
char *mindisc = NULL;
char *maxdisc = NULL;
int i;
int dnum;
mddev_dev_t dv;
int fail=0, warn=0;
struct stat stb;
@ -123,18 +123,19 @@ int Create(char *mddev, int mdfd,
/* now look at the subdevs */
array.active_disks = 0;
array.working_disks = 0;
for (dv=devlist; dv; dv=dv->next) {
dnum = 0;
for (dv=devlist; dv; dv=dv->next, dnum++) {
char *dname = dv->devname;
int dsize, freesize;
int fd;
if (strcasecmp(dname, "missing")==0) {
if (first_missing > i)
first_missing = i;
if (first_missing > dnum)
first_missing = dnum;
missing_disks ++;
continue;
}
array.working_disks++;
if (i < raiddisks)
if (dnum < raiddisks)
array.active_disks++;
fd = open(dname, O_RDONLY, 0);
if (fd <0 ) {
@ -269,13 +270,13 @@ int Create(char *mddev, int mdfd,
return 1;
}
for (i=0, dv = devlist ; dv ; dv=dv->next, i++) {
for (dnum=0, dv = devlist ; dv ; dv=dv->next, dnum++) {
int fd;
struct stat stb;
mdu_disk_info_t disk;
disk.number = i;
if (i >= insert_point)
disk.number = dnum;
if (dnum >= insert_point)
disk.number++;
disk.raid_disk = disk.number;
if (disk.raid_disk < raiddisks)

13
INSTALL Normal file
View File

@ -0,0 +1,13 @@
To build mdadm, simply run:
make
to install, run
make install
as root.
No configuration is necessary.

17
Makefile
View File

@ -37,9 +37,12 @@ CFLAGS = -Wall -Werror -Wstrict-prototypes -ggdb -DCONFFILE=\"$(CONFFILE)\"
# STRIP = -s
INSTALL = /usr/bin/install
DESTDIR = /.
DESTDIR =
BINDIR = /sbin
MANDIR = /usr/share/man/man8
MANDIR = /usr/share/man
MAN4DIR = $(MANDIR)/man4
MAN5DIR = $(MANDIR)/man5
MAN8DIR = $(MANDIR)/man8
OBJS = mdadm.o config.o mdstat.o ReadMe.o util.o Manage.o Assemble.o Build.o Create.o Detail.o Examine.o Monitor.o dlink.o Kill.o Query.o
@ -59,12 +62,14 @@ mdadm.conf.man : mdadm.conf.5
$(OBJS) : mdadm.h
install : mdadm mdadm.8
$(INSTALL) $(STRIP) -m 755 mdadm $(DESTDIR)/$(BINDIR)
$(INSTALL) -m 644 mdadm.8 $(DESTDIR)/$(MANDIR)
install : mdadm mdadm.8 md.4 mdadm.conf.5
$(INSTALL) -D $(STRIP) -m 755 mdadm $(DESTDIR)$(BINDIR)/mdadm
$(INSTALL) -D -m 644 mdadm.8 $(DESTDIR)$(MAN8DIR)/mdadm.8
$(INSTALL) -D -m 644 md.4 $(DESTDIR)$(MAN4DIR)/md.4
$(INSTALL) -D -m 644 mdadm.conf.5 $(DESTDIR)$(MAN5DIR)/mdadm.conf.5
clean :
rm -f mdadm $(OBJS) core mdadm.man
rm -f mdadm $(OBJS) core *.man
dist : clean
./makedist

6
Manage.c
View File

@ -129,7 +129,7 @@ int Manage_subdevs(char *devname, int fd,
mdu_disk_info_t disc;
mddev_dev_t dv;
struct stat stb;
int i,j;
int j;
int save_errno;
static char buf[4096];
@ -151,8 +151,8 @@ int Manage_subdevs(char *devname, int fd,
}
switch(dv->disposition){
default:
fprintf(stderr, Name ": internal error - devmode[%d]=%d\n",
i, dv->disposition);
fprintf(stderr, Name ": internal error - devmode[%s]=%d\n",
dv->devname, dv->disposition);
return 1;
case 'a':
/* add the device - hot or cold */

4
ReadMe.c
View File

@ -29,7 +29,7 @@
#include "mdadm.h"
char Version[] = Name " - v0.8 - 4 April 2002\n";
char Version[] = Name " - v0.8.1 - 6 April 2002\n";
/*
* File: ReadMe.c
*
@ -192,7 +192,7 @@ char Help[] =
" For create or build:\n"
" --chunk= -c : chunk size of kibibytes\n"
" --rounding= : rounding factor for linear array (==chunck size)\n"
" --level= -l : raid level: 0,1,4,5,linear. 0 or linear for build\n"
" --level= -l : raid level: 0,1,4,5,linear,mp. 0 or linear for build\n"
" --paritiy= -p : raid5 parity algorith: {left,right}-{,a}symmetric\n"
" --layout= : same as --parity\n"
" --raid-disks= -n : number of active devices in array\n"

4
makedist
View File

@ -24,3 +24,7 @@ trap "rm $target/$base; exit" 1 2 3
( cd .. ; ln -s mdadm mdadm-$version ; tar czhvf - --exclude='*,v' --exclude='*.o' --exclude mdadm --exclude=RCS mdadm-$version ; rm mdadm-$version ) > $target/$base
chmod a+r $target/$base
ls -l $target/$base
rpm -ta $target/$base
find /home/neilb/src/RPM -name "*mdadm-$version-*" \
-exec cp {} $target/RPM \;

2
md.4
View File

@ -80,7 +80,7 @@ A RAID0 array (which has zero redundancy) is also known as a
striped array.
A RAID0 array is configured at creation with a
.B "Chunk Size"
which must be a multiple of 4 kibibytes.
which must be a power of two, and at least 4 kibibytes.
The RAID0 driver places the first chunk of the array to the first
device, the second chunk to the second device, and so on until all

240
md.man
View File

@ -1,240 +0,0 @@
MD(4) MD(4)
NNAAMMEE
md - Multiple Device driver aka Linux Software Raid
SSYYNNOOPPSSIISS
//ddeevv//mmdd_n
//ddeevv//mmdd//_n
DDEESSCCRRIIPPTTIIOONN
The mmdd driver provides virtual devices that are created
from one or more independent underlying devices. This
array of devices often contains redundancy, and hence the
acronym RAID which stands for a Redundant Array of Inde-
pendent Devices.
mmdd support RAID levels 1 (mirroring) 4 (striped array with
parity device) and 5 (striped array with distributed par-
ity information. If a single underlying device fails
while using one of these level, the array will continue to
function.
mmdd also supports a number of pseudo RAID (non-redundant)
configurations including RAID0 (striped array), LINEAR
(catenated array) and MULTIPATH (a set of different inter-
faces to the same device).
MMDD SSUUPPEERR BBLLOOCCKK
With the exception of Legacy Arrays described below, each
device that is incorporated into an MD array has a _s_u_p_e_r
_b_l_o_c_k written towards the end of the device. This
superblock records information about the structure and
state of the array so that the array can be reliably re-
assembled after a shutdown.
The superblock is 4K long and is written into a 64K
aligned block that starts at least 64K and less than 128K
from the end of the device (i.e. to get the address of the
superblock round the size of the device down to a multiple
of 64K and then subtract 64K). The available size of each
device is the amount of space before the super block, so
between 64K and 128K is lost when a device in incorporated
into an MD array.
The superblock contains, among other things:
LEVEL The manner in which the devices are arranged into
the array (linear, raid0, raid1, raid4, raid5, mul-
tipath).
UUID a 128 bit Universally Unique Identifier that iden-
tifies the array that this device is part of.
LLEEGGAACCYY AARRRRAAYYSS
Early versions of the mmdd driver only supported Linear and
Raid0 configurations and so did not use an MD superblock
(as there is not state that needs to be recorded). While
it is strongly recommended that all newly created arrays
utilise a superblock to help ensure that they are assem-
bled properly, the mmdd driver still supports legacy linear
and raid0 md arrays that do not have a superblock.
LLIINNEEAARR
A linear array simply catenates the available space on
each drive together to form one large virtual drive.
One advantage of this arrangement over the more common
RAID0 arrangement is that the array may be reconfigured at
a later time with an extra drive and so the array is made
bigger without disturbing the data that is on the array.
However this cannot be done on a live array.
RRAAIIDD00
A RAID0 array (which has zero redundancy) is also known as
a striped array. A RAID0 array is configured at creation
with a CChhuunnkk SSiizzee which must be a multiple of 4 kibibytes.
The RAID0 driver places the first chunk of the array to
the first device, the second chunk to the second device,
and so on until all drives have been assigned one chuck.
This collection of chunks forms a ssttrriippee. Further chunks
are gathered into stripes in the same way which are
assigned to the remaining space in the drives.
If device in the array are not all the same size, then
once the smallest devices has been exhausted, the RAID0
driver starts collecting chunks into smaller stripes that
only span the drives which still have remaining space.
RRAAIIDD11
A RAID1 array is also known as a mirrored set (though mir-
rors tend to provide reflect images, which RAID1 does not)
or a plex.
Once initialised, each device in a RAID1 array contains
exactly the same data. Changes are written to all devices
in parallel. Data is read from any one device. The
driver attempts to distribute read requests across all
devices to maximise performance.
All devices in a RAID1 array should be the same size. If
they are not, then only the amount of space available on
the smallest device is used. Any extra space on other
devices is wasted.
RRAAIIDD44
A RAID4 array is like a RAID0 array with an extra device
for storing parity. Unlike RAID0, RAID4 also requires
that all stripes span all drives, so extra space on
devices that are larger than the smallest is wasted.
When any block in a RAID4 array is modified the parity
block for that stripe (i.e. the block in the parity device
at the same device offset as the stripe) is also modified
so that the parity block always contains the "parity" for
the whole stripe. i.e. its contents is equivalent to the
result of performing an exclusive-or operation between all
the data blocks in the stripe.
This allows the array to continue to function if one
device fails. The data that was on that device can be
calculated as needed from the parity block and the other
data blocks.
RRAAIIDD55
RAID5 is very similar to RAID4. The difference is that
the parity blocks for each stripe, instead of being on a
single device, are distributed across all devices. This
allows more parallelism when writing as two different
block updates will quite possibly affect parity blocks on
different devices so there is less contention.
This also allows more parallelism when reading as read
requests are distributed over all the devices in the array
instead of all but one.
MMUUTTIIPPAATTHH
MULTIPATH is not really a RAID at all as there is only one
real device in a MULTIPATH md array. However there are
multiple access points (paths) to this device, and one of
these paths might fail, so there are some similarities.
A MULTIPATH array is composed of a number of different
devices, often fibre channel interfaces, that all refer
the the same real device. If one of these interfaces
fails (e.g. due to cable problems), the multipath driver
to attempt to redirect requests to another interface.
UUNNCCLLEEAANN SSHHUUTTDDOOWWNN
When changes are made to an RAID1, RAID4, or RAID5 array
there is a possibility of inconsistency for short periods
of time as each update requires are least two block to be
written to different devices, and these writes probably
wont happen at exactly the same time. This is a system
with one of these arrays is shutdown in the middle of a
write operation (e.g. due to power failure), the array may
not be consistent.
The handle this situation, the md driver marks an array as
"dirty" before writing any data to it, and marks it as
"clean" when the array is being disabled, e.g. at shut-
down. If the md driver finds an array to be dirty at
startup, it proceeds to correct any possibly inconsis-
tency. For RAID1, this involves copying the contents of
the first drive onto all other drives. For RAID4 or RAID5
this involves recalculating the parity for each stripe and
making sure that the parity block has the correct data.
If a RAID4 or RAID5 array is degraded (missing one drive)
when it is restarted after an unclean shutdown, it cannot
recalculate parity, and so it is possible that data might
be undetectably corrupted. The md driver currently ddooeess
nnoott alert the operator to this condition. It should prob-
ably fail to start an array in this condition without man-
ual intervention.
RREECCOOVVEERRYY
If the md driver detects any error on a device in a RAID1,
RAID4, or RAID5 array, it immediately disables that device
(marking it as faulty) and continues operation on the
remaining devices. If there is a spare drive, the driver
will start recreating on one of the spare drives the data
what was on that failed drive, either by copying a working
drive in a RAID1 configuration, or by doing calculations
with the parity block on RAID4 and RAID5.
Why this recovery process is happening, the md driver will
monitor accesses to the array and will slow down the rate
of recovery if other activity is happening, so that normal
access to the array will not be unduly affected. When no
other activity is happening, the recovery process proceeds
at full speed. The actual speed targets for the two dif-
ferent situations can be controlled by the ssppeeeedd__lliimmiitt__mmiinn
and ssppeeeedd__lliimmiitt__mmaaxx control files mentioned below.
FFIILLEESS
//pprroocc//mmddssttaatt
Contains information about the status of currently
running array.
//pprroocc//ssyyss//ddeevv//rraaiidd//ssppeeeedd__lliimmiitt__mmiinn
A readable and writable file that reflects the cur-
rent goal rebuild speed for times when non-rebuild
activity is current on an array. The speed is in
Kibibytes per second, and is a per-device rate, not
a per-array rate (which means that an array with
more disc will shuffle more data for a given
speed). The default is 100.
//pprroocc//ssyyss//ddeevv//rraaiidd//ssppeeeedd__lliimmiitt__mmaaxx
A readable and writable file that reflects the cur-
rent goal rebuild speed for times when no non-
rebuild activity is current on an array. The
default is 100,000.
SSEEEE AALLSSOO
mmddaaddmm(8), mmkkrraaiidd(8).
MD(4)

2
mdadm.8
View File

@ -196,7 +196,7 @@ Specify rounding factor for linear array (==chunk size)
.TP
.BR -l ", " --level=
Set raid level. Options are: linear, raid0, 0, stripe, raid1, 1, mirror, raid5, 4,
raid5, 5. Obviously some of these are synonymous.
raid5, 5, multipath, mp. Obviously some of these are synonymous.
Only the first 4 are valid when Building.
.TP

2
mdadm.c
View File

@ -592,7 +592,7 @@ int main(int argc, char *argv[])
if (devlist == NULL)
devlist = conf_get_devs(configfile);
if (devlist == NULL) {
fprintf(stderr, Name ": No devices listed in %s\n", configfile);
fprintf(stderr, Name ": No devices listed in %s\n", configfile?configfile:DefaultConfFile);
exit(1);
}
rv = Examine(devlist, devlist?brief:!verbose, scan);

141
mdadm.conf.man
View File

@ -1,141 +0,0 @@
MDADM.CONF(5) MDADM.CONF(5)
NNAAMMEE
mdadm.conf - configuration for management of Software Raid
with mdadm
SSYYNNOOPPSSIISS
/etc/mdadm.conf
DDEESSCCRRIIPPTTIIOONN
mmddaaddmm is a tool for creating, managing, and monitoring
RAID devices using the mmdd driver in Linux.
Some common tasks, such as assembling all arrays, can be
simplified by describing the devices and array in this
configuration file.
SSYYNNTTAAXX
The file should be seen as a collection of words separated
by white space (space, tab, or newline). Any word that
beings with a hash sign (#) starts a comment and that word
together with the remainder of the line are ignored.
Any line that start with white space (space or tab) is
treated as though it were a continuation of the previous
line.
Empty lines are ignored, but otherwise each (non continua-
tion) line must start with a keyword as listed below. The
key words are case insensitive and can be abbreviated to 3
characters.
The keywords are:
DDEEVVIICCEE A ddeevviiccee line lists the devices (whole devices or
partitions) that might contain a component of an MD
array. When looking for the components of an
array, mmddaaddmm will scan these devices and no others.
The ddeevviiccee line may contain a number of different
devices (separated by spaces) and each device name
can contain wild cards as defined by gglloobb(7).
Also, there may be several device lines present in
the file.
For example:
DEVICE /dev/hda* /dev/hdc*
DEV /dev/sd*
DEVICE /dev/discs/disc*/disc
AARRRRAAYY The ARRAY lines identify actual arrays. The second
word on the line should be the name of the device
where the array is normally assembled, such as
//ddeevv//mmdd11. Subsequent words identify the array, or
identify the array as a member of a group. If mul-
tiple identities are given, then the array must
match ALL identities to be considered a match.
Each identity word has a tag, and equals sign, and
some value. The options are:
uuuuiidd== The value should be a 128 bit uuid in hexadeci-
mal, with punctuation interspersed if desired.
This must match the uuid stored in the
superblock.
ssuuppeerr--mmiinnoorr==
The value is an integer which indicates the
minor number that was stored in the superblock
when the array was created. When an array is
created as /dev/mdX, then the minor number X is
stored.
ddeevviicceess==
The value is a comma separated list of device
names. Precisely these devices will be used to
assemble the array. Note that the devices
listed there must also be listed on a DEVICE
line.
lleevveell== The value is a raid level. This is not nor-
mally used to identify an array, but is sup-
ported so that the output of
mmddaaddmm ----eexxaammiinnee ----ssccaann
can be use directly in the configuration file.
ddiisskkss== The value is the number of disks in a complete
active array. As with lleevveell== this is mainly
for compatibility with the output of
mmddaaddmm ----eexxaammiinnee ----ssccaann.
ssppaarree--ggrroouupp==
The value is a textual name for a group of
arrays. All arrays with the same ssppaarree--ggrroouupp
name are considered to be part of the same
group. The significance of a group of arrays
is that mmddaaddmm will, when monitoring the arrays,
move a spare drive from one array in a group to
another array in that group if the first array
had a failed or missing drive but no spare.
MMAAIILLAADDDDRR
The mmaaiillaaddddrr line gives an E-mail address that
alerts should be sent to when is running in ----mmoonnii--
ttoorr mode (and was given the ----ssccaann option). There
should only be one MMAAIILLAADDDDRR line and it should have
only one address.
PPRROOGGRRAAMM
The pprrooggrraamm line gives the name of a program to be
run when mmddaaddmm ----mmoonniittoorr detects potentially inter-
esting events on any of the arrays that it is moni-
toring. This program gets run with two or three
arguments, they being the Event, the md device, and
possibly the related component device.
There should only be one pprrooggrraamm line and it should
be give only one program.
SSEEEE AALLSSOO
mmddaaddmm(8), mmdd(4).
MDADM.CONF(5)

1
mdadm.h
View File

@ -202,3 +202,4 @@ char *human_size_brief(long long bytes);
extern void put_md_name(char *name);
extern char *get_md_name(int dev);
extern char DefaultConfFile[];

20
mdadm.spec
View File

@ -1,6 +1,6 @@
Summary: mdadm is used for controlling Linux md devices (aka RAID arrays)
Name: mdadm
Version: 0.8
Version: 0.8.1
Release: 1
Source: http://www.cse.unsw.edu.au/~neilb/source/mdadm/mdadm-%{version}.tgz
URL: http://www.cse.unsw.edu.au/~neilb/source/mdadm/
@ -29,29 +29,23 @@ some common tasks).
make CFLAGS="$RPM_OPT_FLAGS" SYSCONFDIR="%{_sysconfdir}"
%install
#rm -rf $RPM_BUILD_ROOT
mkdir -p $RPM_BUILD_ROOT/%{_sbindir}
install -m755 mdadm $RPM_BUILD_ROOT/%{_sbindir}
mkdir -p $RPM_BUILD_ROOT/%{_sysconfdir}
install -m644 mdadm.conf-example $RPM_BUILD_ROOT/%{_sysconfdir}/mdadm.conf
mkdir -p $RPM_BUILD_ROOT/%{_mandir}/man4
mkdir -p $RPM_BUILD_ROOT/%{_mandir}/man5
mkdir -p $RPM_BUILD_ROOT/%{_mandir}/man8
install -m644 md.4 $RPM_BUILD_ROOT/%{_mandir}/man4/
install -m644 mdadm.conf.5 $RPM_BUILD_ROOT/%{_mandir}/man5/
install -m644 mdadm.8 $RPM_BUILD_ROOT/%{_mandir}/man8/
make DESTDIR=$RPM_BUILD_ROOT MANDIR=%{_mandir} BINDIR=%{_sbindir} install
install -D -m644 mdadm.conf-example $RPM_BUILD_ROOT/%{_sysconfdir}/mdadm.conf
%clean
rm -rf $RPM_BUILD_ROOT
%files
%defattr(-,root,root)
%doc TODO ChangeLog mdadm.man mdadm.conf-example COPYING
%doc TODO ChangeLog mdadm.conf-example COPYING
%{_sbindir}/mdadm
%config(noreplace,missingok)/%{_sysconfdir}/mdadm.conf
%{_mandir}/man*/md*
%changelog
* Sat Apr 6 2002 <neilb@cse.unsw.edu.au>
- change %install to use "make install"
* Fri Mar 15 2002 <gleblanc@localhost.localdomain>
- beautification
- made mdadm.conf non-replaceable config