2011-04-05 00:40:49 +02:00
|
|
|
/*
|
|
|
|
* mdadm - manage Linux "md" devices aka RAID arrays.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2011 Neil Brown <neilb@suse.de>
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*
|
|
|
|
* Author: Neil Brown
|
|
|
|
* Email: <neilb@suse.de>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "mdadm.h"
|
|
|
|
|
|
|
|
/* name/number mappings */
|
|
|
|
|
|
|
|
mapping_t r5layout[] = {
|
|
|
|
{ "left-asymmetric", ALGORITHM_LEFT_ASYMMETRIC},
|
|
|
|
{ "right-asymmetric", ALGORITHM_RIGHT_ASYMMETRIC},
|
|
|
|
{ "left-symmetric", ALGORITHM_LEFT_SYMMETRIC},
|
|
|
|
{ "right-symmetric", ALGORITHM_RIGHT_SYMMETRIC},
|
|
|
|
|
|
|
|
{ "default", ALGORITHM_LEFT_SYMMETRIC},
|
|
|
|
{ "la", ALGORITHM_LEFT_ASYMMETRIC},
|
|
|
|
{ "ra", ALGORITHM_RIGHT_ASYMMETRIC},
|
|
|
|
{ "ls", ALGORITHM_LEFT_SYMMETRIC},
|
|
|
|
{ "rs", ALGORITHM_RIGHT_SYMMETRIC},
|
|
|
|
|
|
|
|
{ "parity-first", ALGORITHM_PARITY_0},
|
|
|
|
{ "parity-last", ALGORITHM_PARITY_N},
|
|
|
|
{ "ddf-zero-restart", ALGORITHM_RIGHT_ASYMMETRIC},
|
|
|
|
{ "ddf-N-restart", ALGORITHM_LEFT_ASYMMETRIC},
|
|
|
|
{ "ddf-N-continue", ALGORITHM_LEFT_SYMMETRIC},
|
|
|
|
|
2017-04-20 06:19:44 +02:00
|
|
|
{ NULL, UnSet }
|
2011-04-05 00:40:49 +02:00
|
|
|
};
|
|
|
|
mapping_t r6layout[] = {
|
|
|
|
{ "left-asymmetric", ALGORITHM_LEFT_ASYMMETRIC},
|
|
|
|
{ "right-asymmetric", ALGORITHM_RIGHT_ASYMMETRIC},
|
|
|
|
{ "left-symmetric", ALGORITHM_LEFT_SYMMETRIC},
|
|
|
|
{ "right-symmetric", ALGORITHM_RIGHT_SYMMETRIC},
|
|
|
|
|
|
|
|
{ "default", ALGORITHM_LEFT_SYMMETRIC},
|
|
|
|
{ "la", ALGORITHM_LEFT_ASYMMETRIC},
|
|
|
|
{ "ra", ALGORITHM_RIGHT_ASYMMETRIC},
|
|
|
|
{ "ls", ALGORITHM_LEFT_SYMMETRIC},
|
|
|
|
{ "rs", ALGORITHM_RIGHT_SYMMETRIC},
|
|
|
|
|
|
|
|
{ "parity-first", ALGORITHM_PARITY_0},
|
|
|
|
{ "parity-last", ALGORITHM_PARITY_N},
|
|
|
|
{ "ddf-zero-restart", ALGORITHM_ROTATING_ZERO_RESTART},
|
|
|
|
{ "ddf-N-restart", ALGORITHM_ROTATING_N_RESTART},
|
|
|
|
{ "ddf-N-continue", ALGORITHM_ROTATING_N_CONTINUE},
|
|
|
|
|
|
|
|
{ "left-asymmetric-6", ALGORITHM_LEFT_ASYMMETRIC_6},
|
|
|
|
{ "right-asymmetric-6", ALGORITHM_RIGHT_ASYMMETRIC_6},
|
|
|
|
{ "left-symmetric-6", ALGORITHM_LEFT_SYMMETRIC_6},
|
|
|
|
{ "right-symmetric-6", ALGORITHM_RIGHT_SYMMETRIC_6},
|
|
|
|
{ "parity-first-6", ALGORITHM_PARITY_0_6},
|
|
|
|
|
2017-04-20 06:19:44 +02:00
|
|
|
{ NULL, UnSet }
|
2011-04-05 00:40:49 +02:00
|
|
|
};
|
|
|
|
|
2019-11-04 04:27:49 +01:00
|
|
|
/* raid0 layout is only needed because of a bug in 3.14 which changed
|
|
|
|
* the effective layout of raid0 arrays with varying device sizes.
|
|
|
|
*/
|
|
|
|
mapping_t r0layout[] = {
|
|
|
|
{ "original", RAID0_ORIG_LAYOUT},
|
|
|
|
{ "alternate", RAID0_ALT_MULTIZONE_LAYOUT},
|
|
|
|
{ "1", 1}, /* aka ORIG */
|
|
|
|
{ "2", 2}, /* aka ALT */
|
|
|
|
{ "dangerous", 0},
|
|
|
|
{ NULL, UnSet},
|
|
|
|
};
|
|
|
|
|
2011-04-05 00:40:49 +02:00
|
|
|
mapping_t pers[] = {
|
|
|
|
{ "linear", LEVEL_LINEAR},
|
|
|
|
{ "raid0", 0},
|
|
|
|
{ "0", 0},
|
|
|
|
{ "stripe", 0},
|
|
|
|
{ "raid1", 1},
|
|
|
|
{ "1", 1},
|
|
|
|
{ "mirror", 1},
|
|
|
|
{ "raid4", 4},
|
|
|
|
{ "4", 4},
|
|
|
|
{ "raid5", 5},
|
|
|
|
{ "5", 5},
|
|
|
|
{ "multipath", LEVEL_MULTIPATH},
|
|
|
|
{ "mp", LEVEL_MULTIPATH},
|
|
|
|
{ "raid6", 6},
|
|
|
|
{ "6", 6},
|
|
|
|
{ "raid10", 10},
|
|
|
|
{ "10", 10},
|
|
|
|
{ "faulty", LEVEL_FAULTY},
|
|
|
|
{ "container", LEVEL_CONTAINER},
|
2017-04-20 06:19:44 +02:00
|
|
|
{ NULL, UnSet }
|
2011-04-05 00:40:49 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
mapping_t modes[] = {
|
|
|
|
{ "assemble", ASSEMBLE},
|
|
|
|
{ "build", BUILD},
|
|
|
|
{ "create", CREATE},
|
|
|
|
{ "manage", MANAGE},
|
|
|
|
{ "misc", MISC},
|
|
|
|
{ "monitor", MONITOR},
|
|
|
|
{ "grow", GROW},
|
|
|
|
{ "incremental", INCREMENTAL},
|
|
|
|
{ "auto-detect", AUTODETECT},
|
2017-04-20 06:19:44 +02:00
|
|
|
{ NULL, UnSet }
|
2011-04-05 00:40:49 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
mapping_t faultylayout[] = {
|
|
|
|
{ "write-transient", WriteTransient },
|
|
|
|
{ "wt", WriteTransient },
|
|
|
|
{ "read-transient", ReadTransient },
|
|
|
|
{ "rt", ReadTransient },
|
|
|
|
{ "write-persistent", WritePersistent },
|
|
|
|
{ "wp", WritePersistent },
|
|
|
|
{ "read-persistent", ReadPersistent },
|
|
|
|
{ "rp", ReadPersistent },
|
|
|
|
{ "write-all", WriteAll },
|
|
|
|
{ "wa", WriteAll },
|
|
|
|
{ "read-fixable", ReadFixable },
|
|
|
|
{ "rf", ReadFixable },
|
|
|
|
|
|
|
|
{ "clear", ClearErrors},
|
|
|
|
{ "flush", ClearFaults},
|
|
|
|
{ "none", ClearErrors},
|
|
|
|
{ "default", ClearErrors},
|
2017-04-20 06:19:44 +02:00
|
|
|
{ NULL, UnSet }
|
2011-04-05 00:40:49 +02:00
|
|
|
};
|
|
|
|
|
2017-03-29 11:54:15 +02:00
|
|
|
mapping_t consistency_policies[] = {
|
|
|
|
{ "unknown", CONSISTENCY_POLICY_UNKNOWN},
|
|
|
|
{ "none", CONSISTENCY_POLICY_NONE},
|
|
|
|
{ "resync", CONSISTENCY_POLICY_RESYNC},
|
|
|
|
{ "bitmap", CONSISTENCY_POLICY_BITMAP},
|
|
|
|
{ "journal", CONSISTENCY_POLICY_JOURNAL},
|
|
|
|
{ "ppl", CONSISTENCY_POLICY_PPL},
|
2017-04-24 16:03:26 +02:00
|
|
|
{ NULL, CONSISTENCY_POLICY_UNKNOWN }
|
2017-03-29 11:54:15 +02:00
|
|
|
};
|
|
|
|
|
2017-04-20 05:27:58 +02:00
|
|
|
mapping_t sysfs_array_states[] = {
|
|
|
|
{ "active-idle", ARRAY_ACTIVE_IDLE },
|
|
|
|
{ "active", ARRAY_ACTIVE },
|
|
|
|
{ "clear", ARRAY_CLEAR },
|
|
|
|
{ "inactive", ARRAY_INACTIVE },
|
|
|
|
{ "suspended", ARRAY_SUSPENDED },
|
|
|
|
{ "readonly", ARRAY_READONLY },
|
|
|
|
{ "read-auto", ARRAY_READ_AUTO },
|
|
|
|
{ "clean", ARRAY_CLEAN },
|
|
|
|
{ "write-pending", ARRAY_WRITE_PENDING },
|
mdadm: Introduce new array state 'broken' for raid0/linear
Currently if a md raid0/linear array gets one or more members removed while
being mounted, kernel keeps showing state 'clean' in the 'array_state'
sysfs attribute. Despite udev signaling the member device is gone, 'mdadm'
cannot issue the STOP_ARRAY ioctl successfully, given the array is mounted.
Nothing else hints that something is wrong (except that the removed devices
don't show properly in the output of mdadm 'detail' command). There is no
other property to be checked, and if user is not performing reads/writes
to the array, even kernel log is quiet and doesn't give a clue about the
missing member.
This patch is the mdadm counterpart of kernel new array state 'broken'.
The 'broken' state mimics the state 'clean' in every aspect, being useful
only to distinguish if an array has some member missing. All necessary
paths in mdadm were changed to deal with 'broken' state, and in case the
tool runs in a kernel that is not updated, it'll work normally, i.e., it
doesn't require the 'broken' state in order to work.
Also, this patch changes the way the array state is showed in the 'detail'
command (for raid0/linear only) - now it takes the 'array_state' sysfs
attribute into account instead of only rely in the MD_SB_CLEAN flag.
Cc: Jes Sorensen <jes.sorensen@gmail.com>
Cc: NeilBrown <neilb@suse.de>
Cc: Song Liu <songliubraving@fb.com>
Signed-off-by: Guilherme G. Piccoli <gpiccoli@canonical.com>
Signed-off-by: Jes Sorensen <jsorensen@fb.com>
2019-09-03 21:49:01 +02:00
|
|
|
{ "broken", ARRAY_BROKEN },
|
2017-04-20 06:19:44 +02:00
|
|
|
{ NULL, ARRAY_UNKNOWN_STATE }
|
2017-04-20 05:27:58 +02:00
|
|
|
};
|
|
|
|
|
2011-04-05 00:40:49 +02:00
|
|
|
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)
|
|
|
|
{
|
2017-04-21 18:11:21 +02:00
|
|
|
while (map->name && strcmp(map->name, name) != 0)
|
2011-04-05 00:40:49 +02:00
|
|
|
map++;
|
2017-04-20 06:19:44 +02:00
|
|
|
|
|
|
|
return map->num;
|
2011-04-05 00:40:49 +02:00
|
|
|
}
|