Montar una partición única de la imagen del disco completo (dispositivo)

Hice una imagen de todo mi disco con

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

Ahora el problema es que me gustaría montar un sistema de archivos ext4 que estaba en ese disco pero

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

obviamente da un error de superbloque ya que la imagen contiene todo el disco (MBR, otras particiones), no solo la partición que necesito. Así que creo que debería encontrar una manera de hacer que la imagen del disco aparezca en la /dev/carpeta ...

¿Alguien sabe cómo hacer eso?

PD: Siempre puedo hacer una ddcopia de seguridad de la imagen en el disco original, pero eso sería muy inconveniente (actualicé el sistema operativo y me gustaría mantenerlo como está)

Obtenga el diseño de partición de la imagen

$ 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)

Calcule el desplazamiento desde el inicio de la imagen hasta el inicio de la partición

Tamaño del sector * Inicio = (en el caso) 512 * 56 = 28672

Móntelo en / dev / loop0 usando el desplazamiento

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

Ahora la partición reside en / dev / loop0 . Puedes fsck , montarlo, etc.

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

Desmontar

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

Actualización para Ubuntu 16.04: con la nueva, losetupahora es más fácil:

sudo losetup -Pf disk_image.raw

Vea el resto de la respuesta para versiones anteriores de Ubuntu.

Una solución fácil es usar kpartx : determinará el diseño de la partición y asignará cada uno a un dispositivo de bloque. Después de eso, todo lo que tienes que hacer es montar el que quieras.

Abra la Terminal, ubique la imagen del disco e ingrese 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

Esto creado loop0p1y loop0p2bajo /dev/mapper. Desde el resultado puede ver los tamaños de las particiones que le ayudan a identificarlos. Puedes montar el que quieras con:

$ sudo mount /dev/mapper/loop0p2 /mnt

Alternativamente, Nautilus detecta el dispositivo de bloqueo y puede montarlo desde la barra lateral:

Cuando haya terminado, desmonte lo que montó y elimine la asignación del dispositivo:

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

Editar : funciona con util-linux> = 2.21 . En el momento de la escritura barcos ubuntu con la versión 2.20 sólo se

De hombre losetup :

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

Así que solo corre

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

para crear nodos de dispositivo para cada partición de su imagen de disco en el primer dispositivo de bucle no utilizado e imprimirlo en stdout. Si usa el /dev/loop0dispositivo, creará al menos /dev/loop0p1que podrá montar como de costumbre.

Prueba gnome-disk-image-mounter:

gnome-disk-image-mounter sda.img

No se sudorequiere Se montará en /media/your_user_name/partition_name, al igual que las unidades USB.

losetup -P automatización

losetup -Pes el mejor método que comienza en Ubuntu 16.04 como se menciona en https://askubuntu.com/a/496576/52975 , aquí hay funciones para automatizar si es más. 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

Fuente:

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"
)

módulo de bucle max_part config

Este es un método decente antes de 16.04.

loop es un módulo del núcleo, integrado en el núcleo en Ubuntu 14.04.

Si lo configura correctamente, Linux divide automáticamente los dispositivos por usted.

cat /sys/module/loop/parameters/max_part

dice cuántas particiones looppueden generar los dispositivos.

Es 0por defecto en Ubuntu 14.04, razón por la cual no ocurre la división automática.

Para cambiarlo, podemos agregar:

options loop max_part=31

a un archivo en /etc/modprobe, o:

GRUB_CMDLINE_LINUX="loop.max_part=31"

a /etc/default/gruby luego sudo update-grub.

Cómo configurar un parámetro de módulo también se trata en: ¿Cómo agregar parámetros de módulo de kernel?

Después de reiniciar, cuando lo haces:

sudo losetup -f --show my.img

monta la imagen en un /dev/loopXdispositivo y monta automáticamente las particiones en los /dev/loopXpYdispositivos.

Este es el método más conveniente si está dispuesto a reiniciar.

Ver también

• 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 una partición única de la imagen del disco completo (dispositivo)
• https://stackoverflow.com/questions/1419489/loopback-mounting-individual-partitions-from-within-a-file-that-contains-a-parti

Use losetup para adjuntar toda la imagen del disco.

# sudo losetup /dev/loop2 sda.img

Luego use mdadm para crear un dispositivo md y se crearán dispositivos de bloque para todas las particiones.

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

Ahora debería ver los dispositivos de partición.

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

La forma más simple, en mi opinión, es usar mount -o loop,offset=...como se menciona en esta respuesta en StackOverflow . La idea es la siguiente:

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

El método es mejor porque no requiere eliminar el dispositivo de bucle después de desmontar la partición montada.

Para simplificar aún más la tarea (que es necesaria si lo hace con frecuencia), puede usar mi script mountimgpara hacer todo por usted. Solo obténgalo de https://github.com/AlexanderAmelkin/mountimg y úselo así:

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

También puede especificar el tipo de sistema de archivos y cualquier otra opción de montaje adicional si lo desea:

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

Cuando haya terminado con la partición, simplemente umount:

umount /media/sda_image