maps.c

   1 /*
   2  * mdadm - manage Linux "md" devices aka RAID arrays.
   3  *
   4  * Copyright (C) 2011 Neil Brown <neilb@suse.de>
   5  *
   6  *
   7  *    This program is free software; you can redistribute it and/or modify
   8  *    it under the terms of the GNU General Public License as published by
   9  *    the Free Software Foundation; either version 2 of the License, or
  10  *    (at your option) any later version.
  11  *
  12  *    This program is distributed in the hope that it will be useful,
  13  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *    GNU General Public License for more details.
  16  *
  17  *    You should have received a copy of the GNU General Public License
  18  *    along with this program; if not, write to the Free Software
  19  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  *    Author: Neil Brown
  22  *    Email: <neilb@suse.de>
  23  */
  24
  25 #include "mdadm.h"
  26
  27 /* name/number mappings */
  28
  29 mapping_t r5layout[] = {
  30         { "left-asymmetric", ALGORITHM_LEFT_ASYMMETRIC},
  31         { "right-asymmetric", ALGORITHM_RIGHT_ASYMMETRIC},
  32         { "left-symmetric", ALGORITHM_LEFT_SYMMETRIC},
  33         { "right-symmetric", ALGORITHM_RIGHT_SYMMETRIC},
  34
  35         { "default", ALGORITHM_LEFT_SYMMETRIC},
  36         { "la", ALGORITHM_LEFT_ASYMMETRIC},
  37         { "ra", ALGORITHM_RIGHT_ASYMMETRIC},
  38         { "ls", ALGORITHM_LEFT_SYMMETRIC},
  39         { "rs", ALGORITHM_RIGHT_SYMMETRIC},
  40
  41         { "parity-first", ALGORITHM_PARITY_0},
  42         { "parity-last", ALGORITHM_PARITY_N},
  43         { "ddf-zero-restart", ALGORITHM_RIGHT_ASYMMETRIC},
  44         { "ddf-N-restart", ALGORITHM_LEFT_ASYMMETRIC},
  45         { "ddf-N-continue", ALGORITHM_LEFT_SYMMETRIC},
  46
  47         { NULL, UnSet }
  48 };
  49 mapping_t r6layout[] = {
  50         { "left-asymmetric", ALGORITHM_LEFT_ASYMMETRIC},
  51         { "right-asymmetric", ALGORITHM_RIGHT_ASYMMETRIC},
  52         { "left-symmetric", ALGORITHM_LEFT_SYMMETRIC},
  53         { "right-symmetric", ALGORITHM_RIGHT_SYMMETRIC},
  54
  55         { "default", ALGORITHM_LEFT_SYMMETRIC},
  56         { "la", ALGORITHM_LEFT_ASYMMETRIC},
  57         { "ra", ALGORITHM_RIGHT_ASYMMETRIC},
  58         { "ls", ALGORITHM_LEFT_SYMMETRIC},
  59         { "rs", ALGORITHM_RIGHT_SYMMETRIC},
  60
  61         { "parity-first", ALGORITHM_PARITY_0},
  62         { "parity-last", ALGORITHM_PARITY_N},
  63         { "ddf-zero-restart", ALGORITHM_ROTATING_ZERO_RESTART},
  64         { "ddf-N-restart", ALGORITHM_ROTATING_N_RESTART},
  65         { "ddf-N-continue", ALGORITHM_ROTATING_N_CONTINUE},
  66
  67         { "left-asymmetric-6", ALGORITHM_LEFT_ASYMMETRIC_6},
  68         { "right-asymmetric-6", ALGORITHM_RIGHT_ASYMMETRIC_6},
  69         { "left-symmetric-6", ALGORITHM_LEFT_SYMMETRIC_6},
  70         { "right-symmetric-6", ALGORITHM_RIGHT_SYMMETRIC_6},
  71         { "parity-first-6", ALGORITHM_PARITY_0_6},
  72
  73         { NULL, UnSet }
  74 };
  75
  76 mapping_t pers[] = {
  77         { "linear", LEVEL_LINEAR},
  78         { "raid0", 0},
  79         { "0", 0},
  80         { "stripe", 0},
  81         { "raid1", 1},
  82         { "1", 1},
  83         { "mirror", 1},
  84         { "raid4", 4},
  85         { "4", 4},
  86         { "raid5", 5},
  87         { "5", 5},
  88         { "multipath", LEVEL_MULTIPATH},
  89         { "mp", LEVEL_MULTIPATH},
  90         { "raid6", 6},
  91         { "6", 6},
  92         { "raid10", 10},
  93         { "10", 10},
  94         { "faulty", LEVEL_FAULTY},
  95         { "container", LEVEL_CONTAINER},
  96         { NULL, UnSet }
  97 };
  98
  99 mapping_t modes[] = {
 100         { "assemble", ASSEMBLE},
 101         { "build", BUILD},
 102         { "create", CREATE},
 103         { "manage", MANAGE},
 104         { "misc", MISC},
 105         { "monitor", MONITOR},
 106         { "grow", GROW},
 107         { "incremental", INCREMENTAL},
 108         { "auto-detect", AUTODETECT},
 109         { NULL, UnSet }
 110 };
 111
 112 mapping_t faultylayout[] = {
 113         { "write-transient", WriteTransient },
 114         { "wt", WriteTransient },
 115         { "read-transient", ReadTransient },
 116         { "rt", ReadTransient },
 117         { "write-persistent", WritePersistent },
 118         { "wp", WritePersistent },
 119         { "read-persistent", ReadPersistent },
 120         { "rp", ReadPersistent },
 121         { "write-all", WriteAll },
 122         { "wa", WriteAll },
 123         { "read-fixable", ReadFixable },
 124         { "rf", ReadFixable },
 125
 126         { "clear", ClearErrors},
 127         { "flush", ClearFaults},
 128         { "none", ClearErrors},
 129         { "default", ClearErrors},
 130         { NULL, UnSet }
 131 };
 132
 133 mapping_t consistency_policies[] = {
 134         { "unknown", CONSISTENCY_POLICY_UNKNOWN},
 135         { "none", CONSISTENCY_POLICY_NONE},
 136         { "resync", CONSISTENCY_POLICY_RESYNC},
 137         { "bitmap", CONSISTENCY_POLICY_BITMAP},
 138         { "journal", CONSISTENCY_POLICY_JOURNAL},
 139         { "ppl", CONSISTENCY_POLICY_PPL},
 140         { NULL, CONSISTENCY_POLICY_UNKNOWN }
 141 };
 142
 143 mapping_t sysfs_array_states[] = {
 144         { "active-idle", ARRAY_ACTIVE_IDLE },
 145         { "active", ARRAY_ACTIVE },
 146         { "clear", ARRAY_CLEAR },
 147         { "inactive", ARRAY_INACTIVE },
 148         { "suspended", ARRAY_SUSPENDED },
 149         { "readonly", ARRAY_READONLY },
 150         { "read-auto", ARRAY_READ_AUTO },
 151         { "clean", ARRAY_CLEAN },
 152         { "write-pending", ARRAY_WRITE_PENDING },
 153         { NULL, ARRAY_UNKNOWN_STATE }
 154 };
 155
 156 char *map_num(mapping_t *map, int num)
 157 {
 158         while (map->name) {
 159                 if (map->num == num)
 160                         return map->name;
 161                 map++;
 162         }
 163         return NULL;
 164 }
 165
 166 int map_name(mapping_t *map, char *name)
 167 {
 168         while (map->name && strcmp(map->name, name) != 0)
 169                 map++;
 170
 171         return map->num;
 172 }