\documentclass{report}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{textcomp}
\usepackage{geometry}
\geometry{top=15mm, bottom=15mm, left=1cm, right=1cm}
\usepackage[french]{babel}
\usepackage{pslatex}
\usepackage[colorlinks=true,urlcolor=black]{hyperref}
\usepackage{graphicx}
\usepackage{fancyhdr}
\pagestyle{fancy}
\renewcommand{\footrulewidth}{0.4pt}
\fancyfoot[L]{Uubu.fr}
\fancyfoot[R]{dim. mai 22 20:58:04 CEST 2016}
\lfoot{\Large \textit{Uubu.fr}}
\hypersetup{pdfinfo={
Title={mdadm},
Author={Sylvain Girod},
Creator={Bash script from uubu.fr's format version 1},
Producer={Bash script and PDFLaTeX},
Subject={Gestion de périphériques raid},
CreationDate={D:20160522205804},
ModDate={D:20160522205804},
Keywords={raid;storages;Haute Disponibilité}
}}
\begin{document}
 
\begin{center}
{\Huge mdadm }
\end{center}
\vspace{1cm}
 
\begin{flushleft}
 
{\large Gestion de périphériques raid}
 
\vspace{10mm}
 
\hspace{1mm}  Les périphériques RAID logiciel Linux sont implémentés via le pilote md (Multiple Devices). Actuellement, linux supporte les périphériques LINEAR, RAID0, RAID1, RAID4, RAID5, RAID6, RAID10, MULTIPATH, FAULTY, et CONTAINER
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} MULTIPATH]{N'est pas un mécanisme raid logiciel, mais implique des périphériques multiples: chaque périphérique est un chemin vers un stockage physique. Il ne devrait plus être utilisé}
\item[\hspace{1mm} FAULTY]{N'est pas un mécanisme raid, et implique seulement 1 périphérique. Il fournis un couche sur un vrai périphérique qui peut être utilisé pour injecter des fautes}
\item[\hspace{1mm} CONTAINER]{est différent, c'est une collection de périphériques qui sont gérés comme un set. C'est similaire à un jeu de périphériques connectés à un contrôleur RAID hardware. Le jeu de périphériques peut contenir plusieurs RAID, chacun utilisant certains ou tous les blocks dans certains périphériques du set. Par exemple, 2 périphériques d'un set de 5 périphériques peuvent former un RAID 1 en utilisant tout l'espace. Les 3 autres peut avoir un raid5 utilisant la moitie de chaque périphérique, et un raid0 pour la seconde moitié.}
\end{description}
 
\vspace{1cm}{\huge Modes }
 
\
 
\hspace{1mm}  mdadm a de nombreux modes d'opérations:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} assemble]{assemble les composants d'un array précédemment créé en un array actif.}
\item[\hspace{1mm} build]{Construit un tableau sans superblocks.}
\item[\hspace{1mm} create]{Créé un nouvel array avec superblocks.}
\item[\hspace{1mm} follow]{}
\item[\hspace{1mm} monitor]{supervise un ou plusieurs périphériques md et agit sur les changements d'état.}
\item[\hspace{1mm} grow]{Agrandit ou réduit un array.}
\item[\hspace{1mm} incremental assembly]{Ajoute un périphérique dans un array.}
\item[\hspace{1mm} manage]{gérer un array, comme ajouter un nouveau spare, et supprimer a périphérique}
\item[\hspace{1mm} misc]{mode qui fait toutes les autres opérations sur les array actifs tel qu'effacer les anciens superblocks.}
\item[\hspace{1mm} auto-detect]{Demande au kernel d'activer tout les arrays auto-détectés}
\end{description}
 
\vspace{1cm}{\huge Options pour sélectionner un mode }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} -A, --assemble]{assemble un array existant}
\item[\hspace{1mm} -B, --build]{Construit un array sans superblocks}
\item[\hspace{1mm} -C, --create]{Créé un nouvel array}
\item[\hspace{1mm} -F, --follow, --monitor]{Sélectionne le mode monitor}
\item[\hspace{1mm} -G, --grow]{Change la taille d'un array actif}
\item[\hspace{1mm} -I, --incremantal]{Ajoute/supprime un périphérique à un array}
\item[\hspace{1mm} --auto-detect]{Demande au kernel de démarrer les array auto-détectés. ne fonctionne que si md est compilé dans le kernel (pas en module)}
\end{description}
 
\hspace{1mm}  Si un périphérique est donné avant toute options, ou si la première option est --add, --re-add, --add-spare, --fail, --remove, ou --replace, le mode Manage est assumé.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Options non spécifique au mode }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} -v, --verbose]{mode verbeux}
\item[\hspace{1mm} -q, --quiet]{Mode silencieu}
\item[\hspace{1mm} -f, --force]{Force l'action}
\item[\hspace{1mm} -c, --config=]{Spécifie le fichier de configuration ou le répertoire. Défaut: /etc/mdadm/mdadm.conf et /etc/mdadm/mdadm.conf.d/}
\item[\hspace{1mm} -s, --scan]{Scanne la configuration ou /proc/mdstat pour les informations manquantes.}
\item[\hspace{1mm} -e, --metadata=]{Déclare de style de métadonnées de raid à utiliser. Défaut: 1.2 pour --create:}
\end{description}
 
\begin{description} \normalsize
\item[\hspace{6mm} 0, 0.90]{Utilise le format original 0.90. Ce format limite les array à 28 périphériques, et 2To.}
\item[\hspace{6mm} 1, 1.0, 1.1, 1.2 default]{Utilise le nouveau format.}
\item[\hspace{6mm} ddf]{Utilise le format DDF (Disk Data Format) définis par SNIA. En créant un array DDF, un CONTAINER est créé.}
\item[\hspace{6mm} imsm]{Utilise le format Intel Matrix Storage Manager. Cela créé un CONTAINER géré de manière similaire à DDF.}
\end{description}
 
\begin{description} \normalsize
\item[\hspace{1mm} --homehost*]{Remplace tout paramètre HOMEHOST dans la configuration et fournis l'identité de l'hôte qui devrait être considéré le home de tous les arrays. cet homehost est enregistré dans les métadonnées.}
\item[\hspace{1mm} --prefer=]{Quand mdadm a besoin d'afficher le nom d'un périphérique il le trouve normalement dans /dev. Quand un chemin est donné avec cette option, mdadm va préférer un nom plus long s'il contient un composant. par exemple --prefer-by-uuid va préférer un nom dans /dev/by-uuid/}
\item[\hspace{1mm} --home-cluster=]{Spécifie le nom du cluster pour le périphérique md. Le périphérique md peut être assemblé seulement dans le cluster qui match le nom spécifié.}
\end{description}
 
\vspace{1cm}{\huge Options pour create, build, ou grow }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} -n, --raid-devices=]{Spécifie le nombre de périphériques actifs dans l'array, incluant les spare et ceux manquants}
\item[\hspace{1mm} -x, --spare-devices=]{Spécifie le nombre de périphériques spare dans l'array initial}
\item[\hspace{1mm} -z, --size=]{Espace en Kio à utiliser dans chaque disque dans le raid 1/4/5/6. Doit être un multiple de la taille de chunk, et doit laisser 128Kb à la fin du disque pour le superblock RAID.}
\item[\hspace{1mm} -Z, --array-size=]{C'est seulement avec' --grow et son effet n'est pas persistant. Avec cette option, l'array paraît plus petit qu'il ne l'est.}
\item[\hspace{1mm} -c, --chunk=]{Spécifie la taille de chunk en KiO. Défaut: 512KiO. Pour s'assurer de la compatibilité avec les anciennes versions, le défaut à la construction d'un array sans métadonnées persistantes est de 64Ko. C'est seulement significatif pour les raid 0/4/5/6/10. les raid 4/5/6/10 nécessitent un taille en puissance de 2. Dans tous les cas, doit être un multiple de 4Ko.}
\item[\hspace{1mm} --rounding]{Spécifie le facteur d'arrondissement pour un array linéaire. La taille de chaque composant sera arrondi à un multiple de cette taille. Défaut: 0}
\item[\hspace{1mm} -l, --level=]{Définis le niveau de raid. avec --create les options sont: linear, raid0, 0, stripe, raid1, 1, mirror, raid4, 4, raid5, 5, raid6, 6, raid10, 10, mulitpath, mp, faulty, container. Avec --build: linear, stripe, raid0, 0, raid1, multipath, mp, faulty.}
\item[\hspace{1mm} -p, --layout=, --parity=]{Configure le détails de la couche de données pour les raid 5/6/10, et contrôle les modes d'erreur pour faulty. pour un raid5: left-asymmetric, left-symmetric, right-asymmetric, right-symmetric, la, ra, ls, rs. Défaut: left-symmetric. Il est également possible de forcer un raid5 à utiliser une couche raid4 avec parity-first ou parity-last. Pour les raid5 DDF, ddf-zero-restart, ddf-N-restart et ddf-N-contitue. Ces layouts sont également disponible pour le raid6. 4 layouts sont fournis en étape intermédiaire pour convertir un raid5 en raid6: left-symmetric-6, right-symmetric-6, left-asymmetric-6, right-asymmetric-6, et parity-first-6.}
\end{description}
 
\hspace{6mm}  Pour faulty, les options sont: write-transient, wt, read-transient, rt, write-persistent, wp, read-persistent, rp, write-all, read-fixable, rf, clear, flush, none. Chaque mode d'erreur peut être suivi par un nombre, qui est utilisé comme période entre la génération d'erreurs. Pour les raid10: n, o, ou f, suivi par un nombre. Défaut: n2:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{6mm} n]{(near copies) Plusieurs copie d'un block de données sont à un offset similaire dans différents périphériques}
\item[\hspace{6mm} o]{(offset copies) Au lieur de dupliquer les chunks dans un stripe, tous les stripes sont dupliqués mais avec une rotation d'un périphérique pour que les blocks dupliqués soient sur différents périphériques.}
\item[\hspace{6mm} f]{(far copies) Plusieurs copies ont des offsets différents. voir md(4) pour plus de détails.}
\end{description}
 
\begin{description} \normalsize
\item[\hspace{1mm} -b, --bitmap=]{Spécifie un fichier où stocker un bitmap. Ce fichier ne devrait pas exister sauf si --force est donné. Le même fihier devrait être donné en assemblant l'array. Si le mot internal est donné, le bitmap est stocké avec les métadonnées dans l'array, et donc est répliqué sur tous les périphériques Si le mot none est donné avec le mode --grow, tout bitmap présent est supprimé. Is le mot clustered est donné, l'array est créé pour un environnement clusterisé Un bitmap est crée pour chaque nœud comme définis par le paramètre --nodes et sont stockés en interne}
\item[\hspace{1mm} --bitmap-chunk=]{Définis la taille de chunk du bitmap. Chaque bit correspond à autant de Ko de stockage. En utilisant un bitmap basé sur un fichier, le défaut est d'utiliser la taille la plus petite qui fait au moins 4 et au plus 2\textasciicircum 21 chunks}
\item[\hspace{1mm} -W, --write-mostly]{Les périphériques listés dans une commande --build, --create, --add seront flaggés en write-mostly. raid1 uniquement et signifie que le pilote md évite de lire dans ces périphériques si possible. Peut être utile pour un mirroir sur un réseau lent.}
\item[\hspace{1mm} --write-behind=]{Active le mode write-behind (raid1). Si un argument est spécifié, il définis le nombre max d'écritures arriéré permis. Défaut: 256. un bitmap write-extent est requis, et ce mode n'est tenté que sur les disques marqués write-mostly.}
\item[\hspace{1mm} --assume-clean]{Dit à mdadm que l'array pré-existant est correct. peut être utile en tentant une récupération après une erreur majeur}
\item[\hspace{1mm} --backup-file=]{Nécessaire avec --grow utilisé pour augmenter le nombre de périphériques dans un raid 5 ou 6 s'il n'y a pas de disque spare disponible, ou pour réduire, changer le niveau de raid ou le layout.}
\item[\hspace{1mm} --data-offset=]{Les array avec des métadonnées 1.x peut laisser un espace entre le début d'un périphérique et le début des données. Normalement le début des données est calculé automatiquement, mais cette option permet de le spécifier manuellement}
\item[\hspace{1mm} --continue]{Cette option est complémentaire à l'option --freeze-reshape pour assembly. Il est nécessaire quand l'opération --grow est interrompue et n'est pas redémarré automatiquement à cause de l'utilisation de --freeze-reshape durant l'assemblage de l'array.}
\item[\hspace{1mm} -N, --name=]{Définis un nom pour l'array. Seulement effectif en créant un array avec un superblock version 1, ou un array dans un conteneur DDF.}
\item[\hspace{1mm} -R, --run]{Insiste pour que mdadm lance l'array, même si certains composants apparaîssent actif dans un autre array ou système de fichier. Normalement, mdadm demande confirmation pour cela, cette option suprime la question.}
\item[\hspace{1mm} -f, --force]{Insiste pour que mdadm accepte la géométrie et le layout spécifié sans question.}
\item[\hspace{1mm} -o, --readonly]{Démarre l'array en mode lecture seule}
\item[\hspace{1mm} -a, --auto\{=yes,md,mdp,part,p\}\{NN\}]{Instruit mdadm sur la manière de créer un fichier de périphérique si nécessaire, en allouant possiblement un numéro mineur non-utilisé. "md" utilise un array non-partitionnable, "mdp", "part" ou "p" utilise un array partitionnable. "yes" nécessite que le périphérique md ait le format standard. Depuis mdadm 3.0, la création de périphérique est effectuée par udev, donc cette option n'est pas nécessaire}
\item[\hspace{1mm} -a, --add]{Peut être utilisé en mode grow dans 2 cas. Il l'array cible est un array linear, --add peut être utilisé pour ajouter un ou plusieurs périphériques. Si l'option --raid-disks est utilisé pour augmenter le nombre de périphériques dans un array, --add peut être utilisé pour ajouter des périphériques supplémentaire à inclure dans l'array.}
\item[\hspace{1mm} --nodes]{Ne fonction que lorsque l'array est pour un environnement clusterisé. Il spécifie le nombre max de nœuds dans le cluster qui vont utiliser ce périphérique simultannément. Défaut: 4}
\item[\hspace{1mm} --write-journal]{Spécifie un périphérique journal pour l'array raid 4/5/6. Devrait être un SSD avec une durée de vie raisonnable}
\end{description}
 
\vspace{1cm}{\huge Options pour l'assemblage }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} -u, --uuid=]{uuid de l'array à assembler. Les périphériques qui n'ont pas cet uuid sont exclus}
\item[\hspace{1mm} -m, --super-minor=]{numéro mineur du périphérique créé. Les périphériques qui n'ont pas ce numéro mineur sont exclus.}
\item[\hspace{1mm} -N, --name=]{Spécifie le nom de l'array à assembler.}
\item[\hspace{1mm} -f, --force]{Assemble l'array même si les métadonnées dans certains périphériques apparaîssent périmés.}
\item[\hspace{1mm} -R, --run]{Tente de démarrer l'array même si moins de disques sont donné que la dernière fois qu'il a été actif.}
\item[\hspace{1mm} --no-degraded]{Inverse de --run. Ne démarre que si tous les disques attendus sont présents.}
\item[\hspace{1mm} -a, --auto\{=yes,md,mdp,part,p\}\{NN\}]{Voir plus haut}
\item[\hspace{1mm} -b, --bitmap=]{Spécifie le fichier bitmap qui a été donné à la création de l'array.}
\item[\hspace{1mm} --backup-file=]{Si utilisé pour re-définir un array (changer le nombre de périphériques, ou la taille de chunk) et que le système crash durant la section critique, cette option doit également être présent avec --assemble pour permettre à des données possiblement corrompus d'être restaurées.}
\item[\hspace{1mm} --invalid-backup]{Si le fichier nécessaire pour l'option ci-dessus n'est pas disponible, un fichier vide peut être donné avec cette option pour indiquer que le fichier backup est invalide. Dans ce cas les données qui étaient ré-arrangés au moment du crash peuvent être perdus irrévocablement, mais le reste de l'array peut être récupérable. Cette option devrait être utilisée quand dernier recours.}
\item[\hspace{1mm} -U, --update=]{Met à jours le superblock dans chaque périphérique en assemblant l'array. L'argument donné peut être (sparc2.2, summaries, uuid, name, nodes, homehost, home-cluster, resync, byteorder, devicesize, no-bitmap, bbl, no-bbl, metadata, ou super-minor):}
\end{description}
 
\begin{description} \normalsize
\item[\hspace{6mm} sparc2.2]{Ajuste le superblock d'un array qui a été sur une machine Sparc tournant sur un Kernel 2.2 patché.}
\item[\hspace{6mm} super-minor]{Met à jours le champ 'preferred minor' dans chaque superblock pour correspondre au numéro mineur de l'array à assembler.}
\item[\hspace{6mm} uuid]{Change l'uuid de l'array}
\item[\hspace{6mm} name]{Change le nom de l'array stocké dans le superblock. (superblock V1 uniquement)}
\item[\hspace{6mm} nodes]{Change les nœuds de l'array comme stocké dans le superblock bitmap. Ne fonctionne que pour les environnements clusterisés}
\item[\hspace{6mm} homehost]{Change le homehost enregistré dans le superblock. Pour les superblocks V0, c'est identique à uuid, pour V1, met à jours le nom}
\item[\hspace{6mm} home-cluster]{Change le nom du cluster. Ne fonctionne que pour les environnements clusterisés}
\item[\hspace{6mm} resync]{Marque l'array 'dirty' signifiant qu'une redondance dans l'array peut être incorrect, et force un resync}
\item[\hspace{6mm} byteorder]{Permet de déplacer l'array entre des machines avec un byte-order différent.}
\item[\hspace{6mm} summaries]{Corrige les sommaires dans le superblock. (compteurs de périphériques total, fonctionnels, actifs, en erreur, et spare)}
\item[\hspace{6mm} devicesize]{S'applique au métadonnées 1.1 et 1.2, utile quand le périphérique a changé de taille.}
\item[\hspace{6mm} metadata]{Fonction avec les métadonnées 0.90 et va le convertir en v1.0. L'array ne doit pas être durty ni write-intent bitmap}
\item[\hspace{6mm} no-bitmap]{Peut être utilisé quand un array a un bitmap interne qui est corrompus. Ignore le bitmap interne}
\item[\hspace{6mm} bbl]{Réserve l'espace dans chaque périphérique pour une liste de blocks défectueux, de 4k vers la fin du disque.}
\item[\hspace{6mm} no-bbl]{Supprime toute réservation pour la liste de blocks défectueux. Si la liste contient des entrées, il échoue.}
\end{description}
 
\begin{description} \normalsize
\item[\hspace{1mm} --freeze-reshape]{Utilisé dans les scripts de démarrage. Quand un array sous reshape est assemblé au boot, cette option stop le reshape après la section critique. Cela se produit avant l'opération de pivot du système de fichiers et évite de perdre le contexte du système de fichier. Le reshape peut être repris ultérieurement avec --continue de la commande grow.}
\end{description}
 
\vspace{1cm}{\huge Pour le mode Manage }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} -t, --test]{Sauf si une erreur sérieuse se produit, mdadm quitte avec le status 2 si aucun changements n'est fait dans l'array et 0 si au moins un changement a été fait.}
\item[\hspace{1mm} -a, --add]{Périphériques listés à chaud. Si un périphérique apparaît avoir fait partie récemment d'un array, le périphérique est re-ajouté. En cas d'échec ou si le périphérique n'a jamais fait partie de l'array, le périphérique est ajouté comme hot-spare. Si l'array est dégradé, il démarre immédiatement la reconstruction des données sur ce spare.}
\item[\hspace{1mm} --re-add]{Re-ajoute un périphérique qui a été précédemment supprimé de l'array. Si les métadonnées dans le périphérique reportent qu'il est un membre de l'array, et que le slot qui est utilisé est vacant, ce périphérique est ajouté à l'array à la même position. Cela va automatiquement récupérer les données de ce périphérique. Utilisé dans un array qui n'a pas de métadonnées, assume que la récupération basée sur bitmap est suffisante pour rendre le périphérique suffisamment consistant avec l'array. avec des métadonnées V1.x, peut être accompagné avec --update-devicesize, --update=bbl ou --update=no-bbl.}
\item[\hspace{1mm} --add-spare]{Ajoute un périphérique spare. Similaire à --add excepté qu'il ne tente pas de --re-add avant.}
\item[\hspace{1mm} -r, --remove]{Supprime les périphériques listés. Ils ne doivent pas être actifs.}
\item[\hspace{1mm} -f, --fail, --set-faulty]{Marque les périphériques listés en faute.}
\item[\hspace{1mm} --replace]{Marque les périphériques listés à remplacer. Tant qu'un spare est disponible, il reconstruit et remplace le périphérique marqué. C'est similaire à marquer le périphérique en faute, mais il reste en service durant le traitement de récupération.}
\item[\hspace{1mm} --with]{Peut suivre une liste de périphériques --replace. Ces périphériques sont utilisés de préférence pour remplacer les périphériques. Ces périphériques doivent déjà être marqués spare dans l'array.}
\item[\hspace{1mm} --write-mostly]{Les périphériques qui sont ajoutés ou re-ajoutés auront le flag 'write-mostly' mis. Seulement valide pour RAID1 et signifie que md évite toute lecture dans ces périphériques si possible}
\item[\hspace{1mm} --readwrite]{Les périphériques qui sont ajoutés ou re-ajoutés auront le flag 'write-mostly' effacé.}
\item[\hspace{1mm} --cluster-confirm]{Confirme l'existence du périphérique. Émis en réponse à une requête --add par un nœud dans un cluster. Quand un nœud ajoute un périphérique il envoie un message à tous les nœuds dans le cluster pour rechercher un périphérique avec un UUID. Cela traduit en une notification udev avec l'UUID du périphériques à ajouter et le numéro de slot. Le nœud reçevant doit acquiter ce message avec --cluster-confirm. Les arguments valides sont <slot>:<devicename> dans le cas où le périphérique est trouvé ou <slot>:missing si non trouvé.}
\end{description}
 
\hspace{1mm}  Chacune de ces options nécessite que le premier périphérique listé est l'array sur lequel agir, et le reste sont les périphérique à ajouter, supprimer, marqué en faute, etc. les différentes opération peuvent être spécifiée pour différents périphériques (ex: mdadm /dev/md0 --add /dev/sda1 --fail /dev/sdb1 --remove /dev/sdb1 ).
\vspace{5mm} \\
 
 
\hspace{1mm}  Si un array utilise un bitmap write-intent, les périphériques qui ont été supprimés peuvent être re-ajouté de manière à éviter une reconstruction complète et seulement mettre à jour les blocks qui ont été changés depuis qu'il a été supprimé. Pour les array avec des métadonnées persistantes (superblocks) c'est fait automatiquement. Pour les array créés avec --build, mdadm doit indiquer que ce périphérique a été supprimé récemment avec --re-add.
\vspace{5mm} \\
 
 
\hspace{1mm}  Les périphériques peuvent seulement être supprimés d'un array s'ils ne sont pas actifs, par exemple, doivent être spare ou en faute. Pour supprimer un périphérique actif, il faut le marquer en faute avant.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Mode Misc }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} -Q, --query]{Examine un périphérique pour voir si c'est un périphérique md et si c'est un composant d'un array md.}
\item[\hspace{1mm} -D, --detail]{Affiche les détails d'un ou plusieurs périphériques md}
\item[\hspace{1mm} --detail-platform]{Affiche des détails sur les capacités RAID de la plateform (firmware/topologie hardware) pour un format de métadonnées donné. Sans argument, mdadm scanne tous les controleurs à la recherche de leur capacités. Sinon, mdadm ne regarde que le contrôleur spécifié par l'argument sous la forme d'un chemin absolus ou un lien (ex: /sys/devices/pci0000:00/0000:00:1f.2)}
\item[\hspace{1mm} -Y, --export]{Avec --detail, --detail-platform, --examine, ou --incremental, la sortie est formatté en paire clé=valeur pour simpifier l'import dans l'environnement. MD\_STARTED indique si un array a été démarré, qui peut inclure une raison. MD\_FOREIGN indique si l'array est attendu sur cet hôte}
\item[\hspace{1mm} -E, --examine]{Affiche le contenu des métadonnées stockés dans le(s) périphérique(s) spécifié(s). --examine s'applique aux périphériques qui sont des composants d'un array, alors que --detail s'applique à l'array actif.}
\item[\hspace{1mm} --sparc2.2]{Si un array a été créé sur une machine sparc avec un kernel 2.2 patché avec le support RAID, le superblock a été créé de manière incorrect, incompatible avec les kernel 2.4 et +. Cette option fix le superblock avant de l'afficher. Dans ce cas, on peut assembler avec --assemble --update=sparc2.2.}
\item[\hspace{1mm} -X, --examine-bitmap]{Repporte les inforamtions sur le fichier bitmap. L'argument est soit un fichie bitmap externe, ou un composant array dans le cas d'un bitmap interne.}
\item[\hspace{1mm} --examine-badblock]{Liste les blocks défectueux enregistrés dans un périphérique (métadata v1.x)}
\item[\hspace{1mm} --dump=directory, --restore=directory]{Sauve les métadonnées d'une liste de périphériques, ou les restaure.}
\item[\hspace{1mm} -R, --run]{Démarre un array partiellement assemblé. Si --assemble n'a pas suffisamment de périphériques pour démarrer l'array, cette option démarre l'array en mode dégradé.}
\item[\hspace{1mm} -S, --stop]{Désactive un array}
\item[\hspace{1mm} -o, --readonly]{Marque un array en lecture seule}
\item[\hspace{1mm} -w, --readwrite]{Marque l'array en lecture écriture}
\item[\hspace{1mm} --zero-superblock]{Si le périphérique contient un superblock md valide, le block est remplis de zéro. avec --force, le block œu ce superblock devrait être sera écrasé même s'il apparaît non valide}
\item[\hspace{1mm} --kill-subarray=]{Si le périphérique est un conteneur et l'argument spécifie un sous-array inactif dans le conteneur, ce sous-array est supprimé. Supprimer tous les sous-array laisse un conteneur vide ou un superblock spare dans les disques. voir --zero-superblock pour supprimer complètement un superblock.}
\item[\hspace{1mm} --update-subarray=]{Si le périphérique est un conteneur et l'argument spécifie un sous-array dans le conteneur, tente de mettre à jour le superblock doné dans le sous-array.}
\item[\hspace{1mm} -t, --test]{Avec --detail, le code de sortie de mdadm est mis pour refléter le status du périphérique}
\item[\hspace{1mm} -W, --wait]{Pour chaque périphérique md donné, attend la fin d'une resyncho, récupération, ou reshaping avant de quitter.}
\item[\hspace{1mm} --wait-clean]{Pour chaque périphérique md doné ou chaque périphérique dans /proc/mdstat si --scan est donné, s'assure que l'array est marqué clean dès que possible.}
\item[\hspace{1mm} --action=]{Définis le 'sync\_action' pour tous les périphériques donné à idle, frozen, check ou repair. idle annule l'action en cours bien que certaines action vont redémarrer automatiquement. frozen annule l'action en cours et s'assur qu'aucune autre action ne démarre automatiquement.}
\end{description}
 
\vspace{1cm}{\huge Mode assemblage incrémental }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} --rebuild-map, -r]{Reconstruit le fichier de map (/run/mdadm/map) que mdadm utilise pour suivre les array actuellement assemblés}
\item[\hspace{1mm} --run, -R]{Lance un array assemblé dès qu'un nombre minimum de périphériques sont disponibles.}
\item[\hspace{1mm} --scan, -s]{avec -R, scan le fichier de map à la recherche d'array qui sont assemblés incrémentalement et tente de démarrer tous ceux qui ne sont pas déjà démarrés. Si un tel array est listé dans mdadm.conf comme nécessitant un bitmap externe, ce bitmap sera attaché avant.}
\item[\hspace{1mm} --fail, -f]{Permet au système hotplug de supprimer les périphériques qui ont disparus complètement du kernel. Ils sont d'abord mis en faute, puis supprimés de l'array. Cela permet au périphérique en faute d'être automatiquement remplacé par un nouveau périphériques sans métadonnées s'il apparaît au chemin spécifié. Cette option est normallement définis seulement par un script udev.}
\end{description}
 
\vspace{1cm}{\huge Mode Monitor }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} -m, --mail]{Addresse mail où envoyer des alertes}
\item[\hspace{1mm} -p, --program, --alert]{Programme à lancer quant un événements est détecté}
\item[\hspace{1mm} -y, --syslog]{Tous les événements sont reportés via syslog. Les messages ont la facilité 'daemon'}
\item[\hspace{1mm} -d, --delay]{Délay en seconde d'attente avant de resonder les arrays md. Défaut: 60 secondes. Il n'est pas nécessaire de réduire ce délai vu que le kernel alerte immédiatement mdadm en cas de changement.}
\item[\hspace{1mm} -r, --increment]{mdadm génère des événements RebuildNN avec le \% d'incrément donné}
\item[\hspace{1mm} -f, --daemonise]{Lance mdadm en tâche de fond}
\item[\hspace{1mm} -i, --pid-file]{quand mdadm est lancé en mode service, écris le pid du process dans le fichier spécifié}
\item[\hspace{1mm} -1, --oneshot]{Vérifie les arrays seulement une fois. Cela génère des événements NewArray, DegradedArray et SparesMissing.}
\item[\hspace{1mm} -t, --test]{Génère une alert TestMessage pour tout array trouvé au démarrage.}
\item[\hspace{1mm} --no-sharing]{Inhibe la fonctionnalité pour déplacer les spares entre les arrays. Seul un processus de monitoring démarré avec --scan, mais sans ce flag est permis.}
\end{description}
 
\vspace{1cm}{\huge Mode ASSEMBLE }
 
\
 
\hspace{1mm}  Assemble un ou plusieurs arrays RAID depuis des composants pré-existants. Pour chaque array, mdadm doit connaître le périphérique md, l'identité de l'array, et des périphériques. Ils peuvent être trouvés de différentes manières.
\vspace{5mm} \\
 
 
\hspace{1mm}  sans l'option --scan, le premier périphériques donné est le périphérique md. Avec --scan, tous les périphériques listés sont des périphériques md et un assemblage est tenté. Avec --scan, sans périphérique listé, tous les périphériques listés dans le fichier de configuration sont assemblés. Si aucun array n'est décris pas le fichier de configuration, les arrays qui peuvent être trouvé dans des périphériques non-utilisés seront assemblés
\vspace{5mm} \\
 
 
\hspace{1mm}  Sans l'option --scan et avec exactement 1 périphérique donné, mdadm agit comme avec --scan et les informations d'identité sont extraits du fichier de configuration.
\vspace{5mm} \\
 
 
\hspace{1mm}  L'identité peut être donné avec l'option --uuid, --name ou --super-minor.
\vspace{5mm} \\
 
 
\hspace{1mm}  Les périphériques peuvent être donnés dans la commande --assemble ou dans le fichier de configuration. Seul les périphériques qui ont un superblock md contenant la bonne identité seront considérés.
\vspace{5mm} \\
 
 
\hspace{1mm}  Le fichier de configuration est seulement utilisé s'il est explicitement donné avec --config ou requêté avec --scan. Dans ce cas, /etc/mdadm/mdadm.conf ou /etc/mdadm.conf est utilisé.
\vspace{5mm} \\
 
 
\hspace{1mm}  si --scan n'est pas donné, le fichier de configuration sera seulement utilisé pour trouver l'identité d'un array
\vspace{5mm} \\
 
 
\hspace{1mm}  Normallement l'array est démarré après qu'il soit assemblé. Cependant si --scan n'est pas donné et tous les disques attendu ne sont pas listés, l'array n'est pas démarré. Pour forcer l'array à être démarré dans ce cas, utiliser le flag --run
\vspace{5mm} \\
 
 
\hspace{1mm}  Si udev est actif, mdadm ne créé pas d'entrée dans /dev, et laisse faire udev. Il enregistre les informations dans /run/mdadm/map qui permet à udev de choisir le nom correct. Si udev n'est pas configuré, mdadm créé lui-même les périphériques dans /dev. Dans ce cas, --auto peut être suffixé par un nombre correspondant au nombre de partitions à créer au lieu des 4 par défaut.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Auto Assemblage }
 
\
 
\hspace{1mm}  Quand --assemble est utilisé avec --scan et qu'aucun périphérique n'est listé, mdadm tente d'abord d'assembler tous les arrays listés dans le fichier de configuration. Si aucun array n'est listé dans la configuration, il recherche les périphériques disponibles à la recherche d'array et tente d'assembler ce qu'il trouve. Les array qui sont taggés comme appartenant à un homehost donné seront assemblés et démarrés normalement. Les array qui n'appartiennent pas à cet hôte sont démarrés en "read-auto" pour qui rien ne soit écrit dans ce périphérique.
\vspace{5mm} \\
 
 
\hspace{1mm}  Si mdadm trouve un jeu consistant de périphériques qui semblent être dans un array, et si le superblock est taggé comme appartenant à l'hôte donné, il va automatiquement choisir un nom de périphérique et tenter d'assembler l'array. Si l'array utilise des métadonnées v0.90, le numéro mineur enregistré dans le superblock est utilisé pour créer un nom dans /dev/md/. Si l'array utilise des métadonnées v1, le nom dans le superblock est utilisé pour créer un nom dans /dev/md/.
\vspace{5mm} \\
 
 
\hspace{1mm}  Ce comportement peut être modifié par la ligne AUTO dans mdadm.conf. Cette ligne peut indiquer que le type de métadonnées spécifique devrait ou non être automatiquement assemblé. Si un array est trouvé qui n'est pas listé dans mdadm.conf et a un format de métadonnées qui est refusé par la ligne AUTO, il ne sera pas assemblé. La ligne AUTO peut également exiger que tous les arrays identifiés comme appartenant à ce homehost devraient être assemblés sans regarder leur type de métadonnées.
\vspace{5mm} \\
 
 
\hspace{1mm}  Note: L'auto-assemblage ne peut pas être utilisé pour assembler et activer certains array qui doivent être reshape. En particulier quand un backup-file ne peut pas être fournis, tout reshape qui nécessite un backup-file pour continuer ne peut pas être auto assemblé. Un array qui est agrandit et a passé la section critique peut être assemblée en utilisant l'auto-assemblage.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Build Mode }
 
\
 
\hspace{1mm}  Similaire à --create. La différence est qu'il créé un array sans superblock. Avec ces arrays il n'y a pas de différence entre la création initiale de l'array et l'assemblage dans l'array, excepté qu'il y a des données utiles dans le second cas.
\vspace{5mm} \\
 
 
\hspace{1mm}  Le niveau peut être RAID0/1/10, multipath, ou faulty, ou un de leur synonymes. Tous les périphériques doivent être listés et l'array sera démarré une fois complet. Il est souvent approprié d'utiliser --assume-clean avec les raid1/10.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Create Mode }
 
\
 
\hspace{1mm}  Initialise un nouvel array md, associe certains périphériques avec lui, et active l'array. Le périphérique nommé n'existe normalement pas quand mdadm --create est lancé, mais sera créé par udev une fois l'array actif.
\vspace{5mm} \\
 
 
\hspace{1mm}  Quand des périphériques sont ajoutés, ils sont vérifiés pour vois s'ils contiennent des superblocks RAID ou des systèmes de fichier. Ils sont également vérifiés pour voir si la variance dans la taille de périphérique excède 1\%. Si une anomalie est constatée, l'array ne sera pas lancé automatiquement, bien que la présence de --run peut outrepasser cette précaution.
\vspace{5mm} \\
 
 
\hspace{1mm}  Pour créer un array dégradé dans lequel certains périphériques sont manquants, donner simplement le mot 'missing' à la place du nom de périphérique. Cela laisse le slot correspondant vide dans l'array. Pour un raid4/5, au plus un slot peut être manquant, pour un raid6, au plus 2 slots peuvent être manquants. Pour un raid1, seul un périphérique a besoin d'être donné, tous les autres peuvent être manquant.
\vspace{5mm} \\
 
 
\hspace{1mm}  En créant un array RAID5, mdadm créé automatiquement un array dégradé avec un disque spare, parce que créer le spare dans un array dégradé est généralement plus rapide que resynchroniser la parité dans un non-dégradé. Cette fonctionnalité peut être remplacée par l'option --force.
\vspace{5mm} \\
 
 
\hspace{1mm}  En créant un array avec des métadonnées version 1 un nom pour l'array est requis. S'il n'est pas donné avec --name, mdadm en choisis un basé sur le dernier composant du nom du périphérique créé. Donc si /dev/md3 est créé, le nom 3 sera choisis. Si /dev/md/home est créé, home sera choisis.
\vspace{5mm} \\
 
 
\hspace{1mm}  En créant une partition basée sur l'array, en utilisant mdadm avec des métadonnées v1.x, le type de partition devrait être 0xDA. Ce type permet une meilleur précision vu que l'utilisation d'autres (RAID auto-detect 0xFD, ou une partition Linux 0x83), peut créer des problèmes dans le cas de récupération d'array.
\vspace{5mm} \\
 
 
\hspace{1mm}  Un nouvel array a normalement un UUID 128bits aléatoire assigné qui est unique. Il est possible de choisir l'UUID avec l'option --uuid.
\vspace{5mm} \\
 
 
\hspace{1mm}  Si le type d'array support un bitmap write-intent, et si les périphériques dans l'array excèdent 100G, un bitmap write-intent interne sera automatiquement ajouté sauf si explicitement demandé avec l'option --bitmap. Dans ce pas l'espace pour un bitmap est réservé pour qu'il puisse être ajouté avec --grow --bitmat=internal.
\vspace{5mm} \\
 
 
\hspace{1mm}  Si le type de métadonnées le supporte (v1.x), l'espace sera alloué pour stocker une liste de blocks défectueux.
\vspace{5mm} \\
 
 
\hspace{1mm}  En créant un array avec un CONTAINER, on peut donner à mdadm soit la liste des périphériques à utiliser, ou simplement le nom du conteneur. Le premier cas permet de contrôler les périphériques à utiliser pour le raid. Le 2ème cas permet à mdadm de choisir automatiquement quels périphériques utiliser basé sur l'espace disponible.
\vspace{5mm} \\
 
 
\hspace{1mm}  Les options de gestion générales qui sont valides avec --create sont:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} --run]{Insiste pour démarrer l'array, même si des périphériques semblent être utilisés}
\item[\hspace{1mm} --readonly]{démarre en lecture seule - pas encore supporté}
\end{description}
 
\vspace{1cm}{\huge Mode Manage }
 
\
 
\hspace{1mm}  Permet de gérer les périphérique dans un array. Il est possible d'effectuer plusieurs opération en une commande: \textbf{mdadm /dev/md0 -f /dev/hda1 -r /dev/hda1 -a /dev/hda1}, qui va d'abord marque /dev/hda1 en faute, puis le supprimer de l'array, et finallement l'ajouter comme spare. Seul 1 md peut être affecter par une simple commande.
\vspace{5mm} \\
 
 
\hspace{1mm}  Quand un périphérique est ajouté à un array actif, mdadm vérifie pour voir s'il a des métadonnées qui spécifie s'il était récemment un membre de cet array. Si c'est le cas, it tente de ré-ajouter le périphérique. S'il n'y a pas eu de changements depuis qu'il a été supprimé, ou si l'array a un bitmap write-intent qui a été enregistré où les changements ont été faits, le périphérique devient immédiatement un membre et les différences enregistrées dans le bitmap sont résolues.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Mode Misc }
 
\
 
\hspace{1mm}  Le mode MISC inclus des opérations distinct qui opérent sur des périphériques distincts. Les opération sont:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} --query]{Le périphérique devrait être un périphérique md actif. Affiche une description détaillée de l'array. --brief et --scan réduit les détails et formatte la sortie pour être incluse dans mdadm.conf. Le code de sortie donne des informations:}
\end{description}
 
\begin{description} \normalsize
\item[\hspace{6mm} 0]{L'array fonctionne normalement}
\item[\hspace{6mm} 1]{L'array a au moins un disque en erreur}
\item[\hspace{6mm} 2]{L'array a plusieurs disques en erreurs inutilisables}
\item[\hspace{6mm} 4]{Erreur en tentant d'obtenir des informations sur le périphérique}
\end{description}
 
\begin{description} \normalsize
\item[\hspace{1mm} --detail-platform]{Affiche des détails sur les capacités RAID de la plateforme (firmware/topologie hardware). Si les métadonnées sont spécifiées avec -e ou --metadata= le code de retour est:}
\end{description}
 
\begin{description} \normalsize
\item[\hspace{6mm} 0]{Les métadonnées ont énuméré avec succès les composants de la plateforme dans le système}
\item[\hspace{6mm} 1]{Les métadonnées sont indépendante de la plateforme}
\item[\hspace{6mm} 3]{Les métadonnées ont échoué à trouver ses composants de la plateforme}
\item[\hspace{6mm} ]{}
\end{description}
 
\begin{description} \normalsize
\item[\hspace{1mm} --update-subarray=]{Si le périphérique est un conteneur et l'argument spécifie un sous-array dans le conteneur, il tente de mettre à jours le superblock dans le sous-array. C'est similaire à mettre à jours un array en mode assemble aec d'option -U.}
\item[\hspace{1mm} --examine]{Le périphérique devrait être un composant d'un array md. mdadm lit le superblock md du périphérique et affiche le contenu. Si --brief ou --scan est donné, les périphériques qui sont des composant d'un array sont groupés ensemble et affiché comme simple entrée utilisable dans mdadm.conf.}
\item[\hspace{1mm} --dump=dir]{Si le périphérique contient des métadonnées RAID, un fichier sera créé dans le répertoire spécifié et les métadonnées y seront écrites. Le fichier aura la même taille que le périphérique et contient les métadonnées au même emplacement. Cepenadnt le fichier sera sparse, donc seul ces blocs de métadonnées seront alloués. Plusieurs périphériques peuvent être listés.}
\item[\hspace{1mm} --restore=dir]{Inverse de --dump. mdadm localise un fichier dans le répertoire et restore les métadonnées.}
\item[\hspace{1mm} --stop]{Les périphériques devraient être des array md actif à désactiver, tant qu'ils ne sont pas utilisés.}
\item[\hspace{1mm} --run]{Active un array md partiellement assemblé}
\item[\hspace{1mm} --readonly]{Marque un array activ en lecture seule.}
\item[\hspace{1mm} --scan]{excepté avec --examine, force l'opération à être appliqué à tous les array listés dans /proc/mdstat. --examine prend en compte les périphériques dans le fichier de configuration.}
\item[\hspace{1mm} -b, --brief]{mode moins verbeux.}
\end{description}
 
\vspace{1cm}{\huge Mode Monitor }
 
\
 
\hspace{1mm}  vérifie périodiquemenent des array md et repporte tout les événements. De plus, mdadm peut déplacer les disques spare d'un array à un autre s'il est dans le même spare-group ou domain et si l'array de destinatio a un disque en erreur mais pas de spare.
\vspace{5mm} \\
 
 
\hspace{1mm}  Le résultat de la supervision des array est la génération d'événements. Ces événements sont passé à un programme séparé (si spécifié) et peuvent être envoyés par mail.
\vspace{5mm} \\
 
 
\hspace{1mm}  En passant les événements à un programme, celui-ci est lancé une fois par événement, et a 2 ou 3 arguments dans l'ordre: le nom de l'événement, le nom du périphérique md et le nom du périphérique.
\vspace{5mm} \\
 
 
\hspace{1mm}  Si --scan est donné, un programme ou une adresse email doit être spécifié sur la ligne de commande ou dans le fichier de configuration, sinon mdadm ne supervise rien. Sans --scan, mdadm continue de superviser tant qu'il trouve quelque chose à superviser. Si aucun programme ou email n'est donné, chaque événement est reporté sur stdout. Les différents événements sont:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} DeviceDisappeared]{Un array précédemment configuré ne semble plus être configuré (syslog priority: Critical)}
\item[\hspace{1mm} RebuildStarted]{Un array commence la reconstruction (syslog priority: Warning)}
\item[\hspace{1mm} RebuildNN]{où NN est un nombre indiquant le pourcentage de reconstruction effectuée. Les événements sont générés avec un incréments fixé qui peut être spécifié sur la ligne de commande. (syslog priority: Warning)}
\item[\hspace{1mm} RebuildFinished]{Un array a été reconstruit, soit parce qu'il a fini normalement, soit parce qu'il a été annulé. (syslog priority: Warning)}
\item[\hspace{1mm} Fail]{Un périphérique actif d'un aray a été marqué en faute (syslog priority: Critical)}
\item[\hspace{1mm} FailSpare]{Un périphérique spare qui a été reconstruit pour remplacer un périphérique en faute a échoué (syslog priority: Critical)}
\item[\hspace{1mm} SpareActive]{Un disque spare a été reconstruit pour remplacer un périphérique en faute et a réussi la reconstruction (syslog priority: Info)}
\item[\hspace{1mm} NewArray]{Un nouvel array a été détecté dans le fichier /proc/mdstat (syslog priority: Info)}
\item[\hspace{1mm} DegradedArray]{Un array apparaît être dégradé. Ce message n'est pas généré quand mdadm remarque un disque en faute qui a généré la dégradation, mais seulement quand mdadm note qu'un array est dégradé quand il est vu la première fois. (syslog priority: Critical)}
\item[\hspace{1mm} MoveSpare]{Un disque spare a été déplacé d'un array dans un spare-group ou domain vers un autre array. (syslog priority: Info)}
\item[\hspace{1mm} SparesMissing]{La configuration indique qu'un array devrait avoir un certain nombre de périphériques spare, mais mdadm détecte qu'il y en a moins. (syslog priority: Warning)}
\item[\hspace{1mm} TestMessage]{Un array a été trouvé au démarrage, et le flag --test était donné (syslog priority: Info)}
\end{description}
 
\hspace{1mm}  Seul Fail, FailSpare, DegradedArray, SparesMissing et TestMessage sont envoyés par mail. Tous les événements sont envoyés au programme. Chaque événement a un périphériques array associé et possiblement un périphérique physique. Pour Fail, FailSpare, et SpareActive ce disque est le périphérique physique. Pour MoveSpare, ce périphérique est l'array où le spare est déplacé.
\vspace{5mm} \\
 
 
\hspace{1mm}  Pour que mdadm déplace les spares d'un array à un autre, les différents arays doivent être labélisés avec le même spare-group ou les spares doivent être autorisés à migrer via les stratégies de domaine dans le fichier de configuration. les noms des spare-group doievnt être uniques.
\vspace{5mm} \\
 
 
\hspace{1mm}  Quand mdadm détecte qu'un array dans un groupe de spare a moins de périphériques actifs que nécessaire pour que l'array sont complet, et n'a pas de périphériques spare, il recherche un autre array dans le même groupe de spare qui est complet et fonctionnel et possède un spare. Il va tenter de déplacer le spare, et en cas d'erreur en ajoutant le spare à l'array, il le remet dans l'array d'origine.
\vspace{5mm} \\
 
 
\hspace{1mm}  Si le groupe de spare pour un array dégradé n'est pas définis, mdadm recherche les règles de migration de spare spécifié par les lignes POLICY dans mdadm.conf et effectue les même étapes ci-dessus sur les spare qui matchent.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Mode Grow }
 
\
 
\hspace{1mm}  Le mode GROW est utilisé pour changer la taille ou le shape d'un array actif. Pour que cela fonctionne, le kernel doit supporter les changements nécessaire. Les changement supportés sont:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} -]{Changer l'attribut "size" des RAID1/4/5/6.}
\item[\hspace{1mm} -]{Augmenter ou diminuer l'attribut 'raid-devices' des RAID0/1/4/5/6}
\item[\hspace{1mm} -]{Changer la taille de chunk et le layout des RAID0/4/5/6/10}
\item[\hspace{1mm} -]{Convertir entre RAID1 et RAID5, entre RAID5 et RAID6, entre RAID0, RAID4 et RAID5, et entre RAID0 et RAID10.}
\end{description}
 
\vspace{1cm}{\huge Mode Grow }
 
\
 
\hspace{1mm}  Utiliser GROW dans les conteneurs est actuellement supporté seulement pour le format de conteneur IMSM d'Intel. Le nombre de périphériques dans un conteneur peut être augmenté, ce qui affecte tous les array dans le conteneur, ou un array dans un conteneur peut être convertis entre les niveaux supportés par le conteneur, et la conversion est un de ceux listés ci-dessus. Re-dimensionner un array dans un conteneur IMSM avec --grow --siwe n'est pas encore supporté.
\vspace{5mm} \\
 
 
\hspace{1mm}  agrandir (par ex, étendre le nombre de périphériques raid) pour le format de conteneur IMSM a un status expérimental. Il est permis par la variable d'environnement MDADM\_EXPERIMENTAL qui doit être à '1'. Ceci pour les raisons suivantes:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} 1.]{Le check-pointing n'a pas été pleinement testé. Cela peut causer des incompatibilités durant l'expansion: un array qui est étendus ne peut pas voyager entre Windows et les systèmes Linux.}
\item[\hspace{1mm} 2.]{Interrompre l'expansion n'est pas recommandé.}
\end{description}
 
\hspace{1mm}  Note: le Checkpointing natif d'Intel n'utilise pas l'option --backup-file et c'est transparent pour l'assemblage.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Changer la taile }
 
\
 
\hspace{1mm}  Normalement quand un array est construit la taille est donnée par le plus petit des disques. Si tous les petits disques dans un array sont supprimés et remplacés avec des disques plus grand, il faut changer la taille avec GROW pour prendre en compte l'espace supplémentaire. Si la taille est augmentée de cette manière, une resynchro démarre pour s'assurer que les nouvelles parties de l'array sont synchronisées.
\vspace{5mm} \\
 
 
\hspace{1mm}  Noter que quand la taille d'un array change, tout système de fichier qui peut être stocké dans un array doit être explicitement étendu pour utiliser l'espace supplémentaire, ou réduit avant de réduire l'array.
\vspace{5mm} \\
 
 
\hspace{1mm}  Également, la taille d'un array ne peut pas être changé s'il a un bitmap actif. Si un array a un bitmap, il doit être supprimé avant de changer la taille. Une fois le changement complet effectué, un nouveau bitmap peut être créé.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Changer les périphériques raid }
 
\
 
\hspace{1mm}  Un array RAID1 peut fonctionner avec plusieurs périphériques à partir de 1 (bien que 1 n'est pas très utile). Il est parfois souhaitable d'augmenter ou diminuer le nombre de disques actifs. Noter que c'est différents d'ajouter ou supprimer à chaud, qui change le nombre de périphériques inactifs.
\vspace{5mm} \\
 
 
\hspace{1mm}  En réduisant le nombre de périphériques dans un raid1, les slots qui sont supprimés de l'array doivent déjà être vacants. C'est à dire, les périphériques qui étaient dans ces slots doivent être en erreur et supprimés.
\vspace{5mm} \\
 
 
\hspace{1mm}  Changer le nombre de périphériques actifs dans un raid5/6 nécessite plus d'effort. Chaque block dans l'array doit être lu et re-écrit dans un nouvel emplacement. Le kernel est capable d'augmenter le nombre de périphériques dans un raid5 de manière sûre, incluant le redémarrage d'un reshape interrompu. Le kernel est également capable d'augmenter ou diminuer le nombre de périphériques dans un raid5 ou 6.
\vspace{5mm} \\
 
 
\hspace{1mm}  Le kernel est capable de convertir un raid0 en raid4 ou 5. mdadm utilise cette fonctionnalité et la capacité d'ajouter des périphériques à un raid4 pour permettre aux périphériques d'être ajoutés dans un raid0. En demandant cela, mdadm convertis le raid0 en un raid4, ajoute les disques nécessaire et reshape, puis convertit le raid4 en raid0.
\vspace{5mm} \\
 
 
\hspace{1mm}  En diminuant le nombre de disques, la taille de l'array diminue également. S'il y avait des données dans l'array, elles peuvent être supprimées de manière irréversible, donc il faut d'abord réduire le système de fichier dans l'array pour correspondre à la nouvelle taille. Pour éviter tout accident, mdadm exige que la taille de l'array soit réduite avant avec mdadm --grow --array-size. C'est un changement réversible qui rend simplement la fin de l'array inaccessible. L'integrité des données peuvent ainsi être vérifiées avant de réduire le nombre de périphériques.
\vspace{5mm} \\
 
 
\hspace{1mm}  En relocalisant les tout premiers stripes dans un raid5 ou 6, il n'est pas possible de conserver les données sur le disques completement consistant et à l'épreuve des crash. Pour fournir la sécurité requise, mdadm désactive les écritures dans l'array lors du reshaping de la section critique, et créé un backup des données qui sont dans cette section. Pour les agrandissements, ce backup peut être stocké dans un des périphériques sparses de l'array, cependant il peut également être stocksé dans un fichier séparé avec --backup-file, et est obligatoire pour les réductions, changements de niveau de RAID et de layout. Si cette option est utilisée, et que le système crash durant la période critique, le même fichier doit être passé à --assemble pour restaurer le backup et réassembler l'array. En réduisant, le reshape est fait depuis la fin jusqu'au début, donc la section critique est à la fin du reshape.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Changement le level }
 
\
 
\hspace{1mm}  Changer le niveau de RAID d'un array est fait instantannément. Cependant, dans le cas d'un raid5 vers un raid6 cela oblige un layout non-standard du raid6, et dans le raid6 vers un raid5 ce layout non-standard est requis avant le changement. Donc bien que le changement de niveau soit instantanné, le changement de layout peut prendre du temps. Un --backup-file est requis. Si l'array n'est pas simultannément agrandis ou réduit, la taille de l'array restera la même - par exemple, reshape un raid5 à 3 disques en un raid6 à 4 disques - le fichier backup ne sera pas utilisé seulement pour la section critique, mais via toute l'opération reshape, comme décris dans la section sur les changeents de layout.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Changement de taille de chunk et de layout }
 
\
 
\hspace{1mm}  Changer la taille de chunk ou de layout sans également changer le nombre de disques implique une ré-écriture de tous les blocks. Pour éviter la perte de données en cas de crash, un --backup-file doit être fournis. Les petites section de l'array seront copiés dans le fichier backup pendant qu'ils sont réarrangés. Cela signifie que toutes les données seront copiées 2 fois, donc ce type de reshape est très lent.
\vspace{5mm} \\
 
 
\hspace{1mm}  Si le reshape est interrompu, ce fichier backup doit être donné à mdadm --assemble pour que l'array puisse être ré-assemblé. En conséquence, le fichie ne peut pas être stocké dans le périphériques en cours de reshape.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Changement de bitmap }
 
\
 
\hspace{1mm}  Un bitmap write-intent peut être ajouté ou supprimé d'un array actif. On peut ajouter un bitmap interne ou externe. Noter que l'ajout d'un bitmap stocké dans un fichier qui est dans le système de fichier affecté dans le raid peut bloque le système.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Mode Incrémental }
 
\
 
\hspace{1mm}  Ce mode est conçu pour être utilisé en conjonction avec le système de découverte de périphérique. Quand des périphériques sont trouvés dans le système, ils peuvent être passé à mdadm --incremental pour être ajoutés à l'array approprié.
\vspace{5mm} \\
 
 
\hspace{1mm}  Inversement, il peut également être utilisé avec --fail pour faire l'inverse et trouver l'array d'un périphérique particulier et le retirer.
\vspace{5mm} \\
 
 
\hspace{1mm}  Si le périphérique passé est un périphériques conteneur, alors tous les arrays décris par les métadonnées du conteneur seront démarrés.
\vspace{5mm} \\
 
 
\hspace{1mm}  mdadm effectue des tests pour déterminer si le périphérique fait partie d'un array, et dans quel array il devrait être membre. Si un array approprié est trouvé, ou peut être créé, mdadm ajoute le périphérique à l'array et le démarre.
\vspace{5mm} \\
 
 
\hspace{1mm}  Noter que mdadm n'ajoute les périphériques à un array que s'il était fonctionnel (actif ou spare) dans l'array. Le support pour l'inclusion automatique d'un nouveau disque comme un spare dans certains array nécessite une configuration via le fichier de configuration (POLICY). Les tests que mdadm effectue sont les suivants:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} -]{Si le périphérique est permis par mdadm.conf, c'est à dire listé dans une ligne DEVICES. Si DEVICES contient le mot clé 'partitions', tous les périphériques sont permis.}
\item[\hspace{1mm} -]{Si le périphérique a un superblock md valide.}
\end{description}
 
\hspace{1mm}  mdadm conserve une liste d'array qui sont partiellement assemblés dans /run/mdadm/map. Si aucun array n'existe qui matche les métadonnées dans le nouveau périphérique, mdadm doit choisir un nom de périphérique et un numéro d'unité. Si se base sur un nom donné dans mdadm.conf et un nom stocké dans les métadonnées. Si le nom suggère un numéro d'unité, ce nombre est utilisé, sinon un numéro libre est choisis. Normalement, mdadm préfère créer un array partitionnable, cependant si la ligne CREATE dans mdadm.conf suggère un array non-partitionnable, il l'honore.
\vspace{5mm} \\
 
 
\hspace{1mm}  Si l'array n'est pas trouvé dans le fichier de configuration et que ses métadonnées n'identifient pas qu'il appartient au homehost, mdadm choisis un nom pour l'array qui ne rentre pas en conflict avec un array qui appartient à cet hôte. Il le fait en ajoutant un '\_' et un petit nombre au nom préférré par les métadonnées.
\vspace{5mm} \\
 
 
\hspace{1mm}  Une fois un array approprié trouvé ou créé et le périphérique ajouté, mdadm doit décider si l'array est prêt à démarrer. Si compare le nombre de périphériques disponible (non-spare) au nombre de périphériques que les métadonnées suggèrent pour être actif. S'il y a assez de disque, l'array est démarré.
\vspace{5mm} \\
 
 
\hspace{1mm}  --run peut alternativement être passé à mdadm auquel cas l'array sera lancé dès qu'il y a assez de disque. Notes qu'aucune de ces approche n'est vraiment idéal. Si tous les périphériques sont découverts, mdadm -IRs peut être lancé pour démarrer tous les arrays qui sont assemblés incrémentalement. Cela signifie qu'aucune mise à jours des métadonnées n'est faite, ni resyncho ou récupération. De plus, les périphériques qui sont trouvés avant la première écriture peuvent être ajoutés de manière sûre.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Variables d'environnement }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} MDADM\_NO\_MDMON]{Empêche de démarrage de mdmon}
\item[\hspace{1mm} MDADM\_NO\_UDEV]{Ne laisse pas udev créer les fichiers de périphériques}
\item[\hspace{1mm} MDADM\_NO\_SYSTEMCTL]{N'utilise pas systemd pour démarrer les tâches}
\item[\hspace{1mm} IMSM\_NO\_PLATFORM]{À 1, désactive les vérifications de plateform Intel pour les raid IMSM.}
\item[\hspace{1mm} MDADM\_GROW\_ALLOW\_OLD]{Si un array est stoppé durant un reshape, qui utilise un fichier backup, puis il est ré-assemblé, mdadm peut se pleindre que le fichier backup est trop ancien. À 1, ne vérifie pas le fichier backup.}
\item[\hspace{1mm} MDADM\_CONF\_AUTO]{Toute chaîne dans cette variable est ajoutée au démarrage de la ligne AUTO dans le fichier de configuration. Peut être utilisé pour désactiver certains types de métadonnées. (ex: '-ddf -imsm' pour désactiver ces array )}
\end{description}
 
\vspace{1cm}{\huge Exemples }
 
\
 
\hspace{1mm} Voir si un périphérique est un array, ou en fait partie \\
\hspace{1mm} \textbf{mdadm --query /dev/name-of-device} \\
\hspace{1mm} Assembler et démarrer tous les arrays listés dans le fichier de configuration \\
\hspace{1mm} \textbf{mdadm --assemble --scan} \\
\hspace{1mm} Stopper tous les array \\
\hspace{1mm} \textbf{mdadm --stop --scan} \\
\hspace{1mm} Si une adresse email ou un programme est donné dans le fichier de configuration, monitor le status de tous les arrays listé dan ce fichier en les requêtant toutes les 2 minutes \\
\hspace{1mm} \textbf{mdadm --follow --scan --delay=120} \\
\hspace{1mm} Créer /dev/md0 en raid1 avec /dev/hda1 et /dev/hdc1: \\
\hspace{1mm} \textbf{mdadm --create /dev/md0 --level=1 --raid-devices=2 /dev/hd[ac]1} \\
\hspace{1mm} Créer un fichier de configuration prototype qui décris les arrays actifs \\
\hspace{1mm} \textbf{echo 'DEVICE /dev/hd*[0-9] /dev/sd*[0-9]' > mdadm.conf mdadm --detail --scan >> mdadm.conf} \\
\hspace{1mm} Trouver les array qui peuvent être assemblés depuis des disques (pas des partitions), et stocke les informations au format du fichier de configuration. \\
\hspace{1mm} \textbf{echo 'DEVICE /dev/hd[a-z] /dev/sd*[a-z]' > mdadm.conf mdadm --examine --scan --config=mdadm.conf >> mdadm.conf} \\
\hspace{1mm} Créer une liste de périphérique en lisant /proc/partitions et assemble /dev/md0 avec tous les périphériques avec un superblock raid et un numéro mineur 0 \\
\hspace{1mm} \textbf{mdadm -Ac partitions -m 0 /dev/md0} \\
\hspace{1mm} Si le fichier de configuration contient une adresse email ou un programme d'alerte, lance mdadm en fond et monitor tous les périphériques md. Écris également le fichier pid \\
\hspace{1mm} \textbf{mdadm --monitor --scan --daemonise > /run/mdadm/mon.pid} \\
\hspace{1mm} Tente d'incorporer le périphérique nouvellement découvert dans un array approprié \\
\hspace{1mm} \textbf{mdadm -Iq /dev/somedevice} \\
\hspace{1mm} Reconstruit la map d'array depuis les arrays courant, puis démarre ceux qui peuvent l'être \\
\hspace{1mm} \textbf{mdadm --incremental --rebuild-map --run --scan} \\
\hspace{1mm} Tout périphérique composant de /dev/md4 sera marqué en faute et supprimé de l'array \\
\hspace{1mm} \textbf{mdadm /dev/md4 --fail detached --remove detached} \\
\hspace{1mm} l'array /dev/md4 qui est un RAID5 sera convertis en RAID6. Il devrait normalement y avoir un disque spare dans l'array avant \\
\hspace{1mm} \textbf{mdadm --grow /dev/md4 --level=6 --backup-file=/root/backup-md4} \\
\hspace{1mm} Créer un array DDF avec 6 disques \\
\hspace{1mm} \textbf{mdadm --create /dev/md/ddf --metadata=ddf --raid-disks 6 /dev/sda /dev/sdb /dev/sdc /dev/sdd /dev/sde /dev/sdf} \\
\hspace{1mm} Créer un raid5 avec 3 périphériques dans le jeu DDF donné. N'utilise que 30Go dans chaque disque \\
\hspace{1mm} \textbf{mdadm --create /dev/md/home -n3 -l5 -z 30000000 /dev/md/ddf} \\
\hspace{1mm} Assemble un array ddf pré-existant \\
\hspace{1mm} \textbf{mdadm -A /dev/md/ddf1 /dev/sda /dev/sdb /dev/sdc /dev/sdd /dev/sde /dev/sdf} \\
\hspace{1mm} Assemble tous les arrays contenus dans l'array ddf, assignant un nom approprié \\
\hspace{1mm} \textbf{mdadm -I /dev/md/ddf1} \\
\hspace{1mm} Affiche l'aide pour le mode création \\
\hspace{1mm} \textbf{mdadm --create --help} \\
\hspace{1mm} Affiche l'aide sur le format du fichier de configuration \\
\hspace{1mm} \textbf{mdadm --config --help} \\
 
\vspace{1cm}{\huge Fichiers }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} /proc/mdstat]{}
\item[\hspace{1mm} /etc/mdadm/mdadm.conf (ou /etc/mdadm.conf)]{}
\item[\hspace{1mm} /etc/mdadm/mdadm.conf.d (ou /etc/mdadm.conf.d)]{}
\item[\hspace{1mm} /run/mdadm/map]{}
\end{description}
 
\vspace{1cm}{\huge Noms des périphériques }
 
\
 
\hspace{1mm}  mdadm comprend 2 types de noms pour les périphériques array. Le premier est dit standard, qui matche les noms utilisés par le kernel et qui apparaîssent dans /proc/mdstat.
\vspace{5mm} \\
 
 
\hspace{1mm}  Le second peut être librement choisi, mais doit résider dans /dev/md/. En donnant un nom à mdadm pour créer ou assembler un array, le chemin complet doit être donné, ou le suffixe du second type de nom.
\vspace{5mm} \\
 
 
\hspace{1mm}  Quand mdadm choisis les noms de périphérique durant l'auto-assemblage ou l'assemblage incrémental, il ajoute parfois une petite séquence de nombre à la fin du nom pour éviter les conflits entre plusieurs array de même nom. Si mdadm peut déterminer que l'array est vraiment déstiné à cet hôte, soit par un hostname dans les métadonnées, ou par la présence de l'array dans mdadm.conf, il n'utilise pas le suffixe si possible. Également, si le homehost est spécifié en <ignore>, mdadm n'utilise le suffixe que si un array différent de même nom existe déja ou est listé dans la configuration.
\vspace{5mm} \\
 
 
\hspace{1mm} Les noms standard sont sous la forme: \\
\hspace{1mm} \textbf{/dev/mdNN} \\
\hspace{1mm} où \textbf{NN} est un nombre. Les noms standard pour les arrays partitionnables sont sous la forme: \\
\hspace{1mm} \textbf{/dev/md\_dNN} \\
\hspace{1mm} Les numéro de partition sont indiqués en ajoutant pMM (ex: /dev/md/d1p2) \\
\hspace{1mm} Depuis le kernel 2.6.28 un array non-partitionnable peut être partitionné, donc md\_dNN n'est plus nécessaire, et des partitions /dev/mdNNpXX sont possibles. \\
\hspace{1mm} Depuis le kernel 2.6.29 les noms standard peut être non-numérique: \\
\hspace{1mm} \textbf{/dev/md\_XXX} \\
\hspace{1mm} où \textbf{XXX} est une chaine. Ces noms sont supportés par mdadm v3.3. \\
\end{flushleft}
\end{document}
