Montar partição única a partir da imagem de todo o disco (dispositivo)

Eu fiz uma imagem do meu disco inteiro com

dd if=/dev/sda of=/media/external_media/sda.img

Agora, o problema é que eu gostaria de montar um sistema de arquivos ext4 que estava naquele disco, mas

mount -t ext4 -o loop /media/external_media/sda.img /media/sda_image

obviamente dá um erro de superbloco, já que a imagem contém todo o disco (MBR, outras partições) e não apenas a partição de que preciso. Acho que devo encontrar uma maneira de fazer a imagem do disco aparecer na /dev/pasta ...

Alguém sabe como fazer isso?

PS: Sempre posso ddfazer o backup da imagem no disco original, mas isso seria muito inconveniente (atualizei o sistema operacional e gostaria de mantê-lo como está)

Obter o layout da partição da imagem

$ sudo fdisk -lu sda.img
...
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
...
  Device Boot      Start         End      Blocks   Id  System
sda.img1   *          56     6400000     3199972+   c  W95 FAT32 (LBA)

Calcular o deslocamento desde o início da imagem até o início da partição

Tamanho do setor * Início = (no caso) 512 * 56 = 28672

Monte-o em / dev / loop0 usando o deslocamento

sudo losetup -o 28672 /dev/loop0 sda.img

Agora a partição reside em / dev / loop0 . Você pode fsck , montar etc

sudo fsck -fv /dev/loop0
sudo mount /dev/loop0 /mnt

Desmontar

sudo umount /mnt
sudo losetup -d /dev/loop0

Atualização para o Ubuntu 16.04: Com o novo, losetupagora é mais fácil:

sudo losetup -Pf disk_image.raw

Veja o restante da resposta para versões mais antigas do Ubuntu.

Uma solução fácil é usar o kpartx : ele descobrirá o layout da partição e mapeará cada um para um dispositivo de bloco. Depois disso, tudo o que você precisa fazer é montar o que deseja.

Abra o Terminal, localize a imagem do disco e digite este comando:

$ sudo kpartx -av disk_image.raw 
add map loop0p1 (252:2): 0 3082240 linear /dev/loop0 2048
add map loop0p2 (252:3): 0 17887232 linear /dev/loop0 3084288

Isso criou loop0p1e está loop0p2abaixo /dev/mapper. A partir da saída, você pode ver os tamanhos das partições, o que ajuda a identificá-las. Você pode montar o que deseja com:

$ sudo mount /dev/mapper/loop0p2 /mnt

Como alternativa, o dispositivo de bloco é detectado pelo Nautilus e você pode montá-lo na barra lateral:

Quando terminar, desmonte o que você montou e remova o mapeamento do dispositivo:

$ sudo umount /mnt
$ sudo kpartx -d disk_image.raw

Edit : trabalha com util-linux> = 2.21 . No momento da escrita, o ubuntu é fornecido apenas com a versão 2.20

Do man losetup :

       -P, --partscan
          force kernel to scan partition table on newly created loop device

Então apenas corra

$ sudo losetup -f --show -P /path/to/image.img

para criar nós de dispositivo para cada partição da imagem do disco no primeiro dispositivo de loop não utilizado e imprimi-lo no stdout. Se estiver usando o /dev/loop0dispositivo, isso criará pelo menos /dev/loop0p1que você poderá montar como de costume.

Tente gnome-disk-image-mounter:

gnome-disk-image-mounter sda.img

Não é sudonecessário. Ele será montado /media/your_user_name/partition_name, exatamente como as unidades USB.

losetup -P automação

losetup -Pé o melhor método a partir do Ubuntu 16.04, conforme mencionado em https://askubuntu.com/a/496576/52975 , e aqui estão as funções para automatizar ainda mais. Uso:

$ los my.img
/dev/loop0
/mnt/loop0p1
/mnt/loop0p2

$ ls /mnt/loop0p1
/whatever
/files
/youhave
/there

$ sudo losetup -l
NAME       SIZELIMIT OFFSET AUTOCLEAR RO BACK-FILE                                                                                      DIO
/dev/loop1         0      0         0  0 /full/path/to/my.img

$ # Cleanup.
$ losd 0
$ ls /mnt/loop0p1
$ ls /dev | grep loop0
loop0

Fonte:

los() (
  img="$1"
  dev="$(sudo losetup --show -f -P "$img")"
  echo "$dev"
  for part in "$dev"?*; do
    if [ "$part" = "${dev}p*" ]; then
      part="${dev}"
    fi
    dst="/mnt/$(basename "$part")"
    echo "$dst"
    sudo mkdir -p "$dst"
    sudo mount "$part" "$dst"
  done
)
losd() (
  dev="/dev/loop$1"
  for part in "$dev"?*; do
    if [ "$part" = "${dev}p*" ]; then
      part="${dev}"
    fi
    dst="/mnt/$(basename "$part")"
    sudo umount "$dst"
  done
  sudo losetup -d "$dev"
)

configuração do max_part do módulo de loop

Este é um método decente antes de 16.04.

loop é um módulo do kernel, embutido no kernel no Ubuntu 14.04.

Se você configurá-lo corretamente, o Linux divide automaticamente os dispositivos para você.

cat /sys/module/loop/parameters/max_part

diz quantas partições os loopdispositivos podem gerar.

É 0por padrão no Ubuntu 14.04 e é por isso que nenhuma divisão automática acontece.

Para mudar, podemos adicionar:

options loop max_part=31

para um arquivo /etc/modprobeou:

GRUB_CMDLINE_LINUX="loop.max_part=31"

para /etc/default/grube então sudo update-grub.

Como definir um parâmetro do módulo também é abordado em: Como adicionar parâmetros do módulo do kernel?

Após uma reinicialização, quando você faz:

sudo losetup -f --show my.img

monta a imagem em um /dev/loopXdispositivo e monta automaticamente as partições em /dev/loopXpYdispositivos.

Portanto, este é o método mais conveniente se você estiver disposto a reiniciar.

Veja também

• https://unix.stackexchange.com/questions/9099/reading-a-filesystem-from-a-whole-disk-image
• https://superuser.com/questions/117136/how-can-i-mount-a-partition-from-dd-created-image-of-a-block-device-eg-hdd-u
• Montar partição única a partir da imagem de todo o disco (dispositivo)
• https://stackoverflow.com/questions/1419489/loopback-mounting-individual-partitions-from-within-a-file-that-contains-a-parti

Use losetup para anexar toda a imagem do disco.

# sudo losetup /dev/loop2 sda.img

Em seguida, use mdadm para criar um dispositivo md e os dispositivos de bloco serão criados para todas as partições.

# sudo mdadm --build --level=0 --force --raid-devices=1 /dev/md2 /dev/loop2
mdadm: array /dev/md2 built and started.

Agora você deve ver os dispositivos de partição.

nile-172-b0fef38-76:/mnt/sdb1 # ls -l /dev/md2*
brw-rw---- 1 root disk   9, 2 Oct 10 12:37 /dev/md2
brw-rw---- 1 root disk 259, 0 Oct 10 12:37 /dev/md2p1

A maneira mais simples, na minha opinião, é usar mount -o loop,offset=...como mencionado nesta resposta no StackOverflow . A ideia é a seguinte:

fdisk -l $IMAGE
# calculate the offset in bytes
mount -o loop,offset=$OFFSET $IMAGE $MOUNTPOINT

O método é melhor porque não requer a exclusão do dispositivo de loop depois de desmontar a partição montada.

Para simplificar ainda mais a tarefa (que é necessária se você a fizer com frequência), você pode usar meu script mountimgpara fazer tudo por você. Basta obtê-lo em https://github.com/AlexanderAmelkin/mountimg e usar assim:

mountimg /media/external_media/sda.img 2 /media/sda_image

Você também pode especificar o tipo de sistema de arquivos e outras opções de montagem adicionais, se desejar:

mountimg /media/external_media/sda.img 2 /media/sda_image -t vfat -o codepage=866,iocharset=utf-8

Quando você terminar a partição, simplesmente umount:

umount /media/sda_image