Como mapear um nome de dispositivo sata para uma interface sata física para sistemas RAID

Question

Eu tenho um sistema com 10 portas SATA e outro SATA como o disco de inicialização. As 10 portas SATA formam 5 arrays RAID1 de software. Os discos RAID podem ser removidos entre as inicializações e trocados com discos em branco arbitrários a qualquer momento.

Eu preciso garantir que / dev / sda seja sempre minha primeira porta SATA física, e / dev / sdj seja sempre o décimo para que os arrays RAID1 funcionem corretamente . Se, por exemplo, o primeiro disco na primeira porta falhar, isso deve ser marcado como um disco ausente e, portanto, o disco na próxima porta deve ser / dev / sdb. Atualmente, o próximo disco disponível é montado como / dev / sda - destruindo completamente meus arrays - e minha configuração de inicialização.

Imagine um cenário horrível em que todos os outros discos falham, portanto, cada matriz RAID1 tem apenas 1 disco de trabalho em seu par. A numeração deve ser:

/ dev / sda / dev / sdc / dev / sde / dev / sdg / dev / sdi

NÃO:

/ dev / sda / dev / sdb / dev / sdc / dev / sdd / dev / sde

Eu vi regras do udev para rotular discos específicos por UUIDs, mas como os usuários hotswapping os discos arbitrariamente, isso não é conveniente.

Por padrão, o Linux rotulará o próximo disco disponível com o próximo caractere alfabético. Existem muitas situações em que um único disco quebrado quebrará vários arrays RAID 1.

• Como posso mapear um dispositivo para uma interface de hardware específica? Isso é possível?
• É possível ter um dispositivo "ausente" na inicialização, para que os dispositivos subseqüentes não sejam identificados incorretamente?

Answer 1

O Debian Wiki tem uma entrada excelente descrevendo o que eu precisava. Depois disso, criei minhas próprias regras em /etc/udev/rules.d/20-disk-bay.rules. Eu incluí apenas os dois primeiros mapeamentos de porta sata como exemplo:

# There are different DEVPATHs for major kernel versions!
# Example for SATA N:
#
# Kernel < 3 DEVPATH
# *1f.2/hostN/targetN:0:0/N:0:0:0*
#
# Kernel > 3 DEVPATH
# *1f.2/ata(N+1)/host*

########## Map SATA 0 to /dev/sdb ##############

# Kernel < 3

KERNEL=="sd?", SUBSYSTEM=="block", DEVPATH=="*1f.2/host0/target0:0:0/0:0:0:0*", NAME="sdb", RUN+="/usr/bin/logger My disk ATTR{partition}=$ATTR{partition}, DEVPATH=$devpath, ID_PATH=$ENV{ID_PATH}, ID_SERIAL=$ENV{ID_SERIAL}", GOTO="END_20_PERSISTENT_DISK"

KERNEL=="sd?*", ATTR{partition}=="1", SUBSYSTEM=="block", DEVPATH=="*1f.2/host0/target0:0:0/0:0:0:0*", NAME="sdb%n", RUN+="/usr/bin/logger My partition parent=%p number=%n, ATTR{partition}=$ATTR{partition}"

# Kernel > 3

KERNEL=="sd?", SUBSYSTEM=="block", DEVPATH=="*1f.2/ata1/host*", NAME="sdb", RUN+="/usr/bin/logger My disk ATTR{partition}=$ATTR{partition}, DEVPATH=$devpath, ID_PATH=$ENV{ID_PATH}, ID_SERIAL=$ENV{ID_SERIAL}", GOTO="END_20_PERSISTENT_DISK"

KERNEL=="sd?*", ATTR{partition}=="1", SUBSYSTEM=="block", DEVPATH=="*1f.2/ata1/host*", NAME="sdb%n", RUN+="/usr/bin/logger My partition parent=%p number=%n, ATTR{partition}=$ATTR{partition}"

########## Map SATA 1 to /dev/sdc ##############

# Kernel < 3

KERNEL=="sd?", SUBSYSTEM=="block", DEVPATH=="*1f.2/host1/target1:0:0/1:0:0:0*", NAME="sdc", RUN+="/usr/bin/logger My disk ATTR{partition}=$ATTR{partition}, DEVPATH=$devpath, ID_PATH=$ENV{ID_PATH}, ID_SERIAL=$ENV{ID_SERIAL}", GOTO="END_20_PERSISTENT_DISK"

KERNEL=="sd?*", ENV{DEVTYPE}=="partition", SUBSYSTEM=="block", DEVPATH=="*1f.2/host1/target1:0:0/1:0:0:0*", NAME="sdc%n", RUN+="/usr/bin/logger My partition parent=%p number=%n, ATTR{partition}=$ATTR{partition}"

# Kernel > 3

KERNEL=="sd?", SUBSYSTEM=="block", DEVPATH=="*1f.2/ata2/host*", NAME="sdc", RUN+="/usr/bin/logger My disk ATTR{partition}=$ATTR{partition}, DEVPATH=$devpath, ID_PATH=$ENV{ID_PATH}, ID_SERIAL=$ENV{ID_SERIAL}", GOTO="END_20_PERSISTENT_DISK"
KERNEL=="sd?*", ATTR{partition}=="1", SUBSYSTEM=="block", DEVPATH=="*1f.2/ata2/host*", NAME="sdc%n", RUN+="/usr/bin/logger My partition parent=%p number=%n, ATTR{partition}=$ATTR{partition}"

LABEL="END_20_PERSISTENT_DISK"

As regras acima sempre mapearão qualquer unidade colocada na porta SATA 0, a primeira porta SATA física na minha placa-mãe, como / dev / sdb e qualquer unidade colocada no SATA 1 como / dev / sdc Os mapeamentos consistentes de portas físicas são críticos no meu caso de uso, pois tenho 5 arrays RAID-1 nos quais os discos podem ser arbitrariamente trocados de seus compartimentos de hotswap físico. Um usuário não técnico pode trocar esses discos a qualquer momento sem ter que lidar com IDs de dispositivos - o sistema é totalmente autônomo e não construirá os arrays RAID nos discos errados nos compartimentos de hotswap. Este é um caso de uso muito específico, mas espero que ajude alguém no futuro.

    

Answer 2

Se você criar uma matriz com:

mdadm --create --name=DATA00 --level=6 --auto=part --verbose /dev/md0 --raid-devices=6 /dev/sda1 /dev/sdb1 /dev/sdd1 /dev/sde1 /dev/sdf1 /dev/sdg1

e faça:

mdadm --detail --scan >> /etc/mdadm/mdadm.conf

você recebe uma entrada em mdadm.conf como:

ARRAY /dev/md/DATA00 metadata=1.2 name=owl:DATA00 UUID=5eeada67:ff994361:bae3ab52:d9e8bd49

Não há necessidade de se referir às partições originais e / ou pedidos de drivers, pois o UUID cuida disso. Quais partições reais constituem o array após a ativação / reinicialização podem ser vistas em /proc/mdstat . Para examinar uma partição individual (incluindo seu UUID), use mdadm --examine /dev/sdXY

Dado que existe never a necessidade de ter uma ordem particular em suas unidades após a reinicialização e como meu BIOS muda as coisas dependendo se eu tenho um SATA externo conectado ou não, estou muito feliz que isso não importa.

    

Answer 3

Por que os usuários trocam discos de forma arbitrária?

Muitas trocas a quente significam que os discos provavelmente serão usados mais rapidamente. A vantagem do ataque na velocidade será perdida. Na verdade, o desempenho do array provavelmente será pior do que um único disco enquanto ele está se recuperando.

O hábito de extrair discos arbitrariamente, mais cedo ou mais tarde, o levará a uma situação em que alguém extraia dois discos pertencentes ao mesmo array, provavelmente causando danos ao sistema como conseqüência.

Sem mencionar os problemas que você descreveu aqui. E eu não tenho certeza se o mdadm vai pegar um novo disco sem que ele seja adicionado manualmente ao array, mas pode haver maneiras de contornar isso.

Este é um esquema de backup? Então eu altamente desencorajo isso! Use o backup convencional - talvez com instantâneos do LVM, se você tiver o LVM.

Se os usuários estiverem "abusando" de seus servidores, coloque um bloqueio na porta da sala do servidor ... ou prive-os das chaves fornecidas com a maioria dos compartimentos hot swap ... ou informe ao gerenciamento que o sistema é importante o suficiente para ter invasão - está a arriscar tempo devido a este comportamento.

Não faça discos hot swap, a menos que os discos estejam quebrados ou sejam substituídos devido à idade avançada!

Hot swap é uma ferramenta para permitir uptime ininterrupto do sistema ao substituir discos que estão quebrados, velhos ou precisam ser substituídos por algum outro motivo, irregular - que é praticamente bom para o qual é bom o suficiente quando se trata de sistemas muito importantes).

Quando um disco se rompe, você pode ter um disco sobressalente extra adicionado à matriz de ataque antecipadamente, fazendo com que o disco sobressalente seja sincronizado automaticamente ou você terá que adicionar manualmente o disco de substituição com troca a quente.

Veja a resposta de Anthon ou este guia: link