Monter une seule partition à partir de l'image du disque entier (périphérique)

J'ai fait une image de tout mon disque avec

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

Maintenant, le problème est que je voudrais monter un système de fichiers ext4 qui était sur ce disque, mais

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

donne évidemment une erreur de superbloc puisque l'image contient le disque entier (MBR, autres partitions) et pas seulement la partition dont j'ai besoin. Je suppose donc que je devrais trouver un moyen de faire apparaître l’image disque dans le /dev/dossier ...

Est-ce que quelqu'un sait comment faire ça?

PS: Je peux toujours ddsauvegarder l’image sur le disque d’origine, mais ce serait très pratique (j’ai mis à jour le système d’exploitation et j’aimerais le conserver tel quel)

Obtenir la disposition de la partition de l'image

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

Calculer le décalage du début de l'image au début de la partition

Taille du secteur * Début = (dans le cas) 512 * 56 = 28672

Montez-le sur / dev / loop0 en utilisant l'offset

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

Maintenant, la partition réside sur / dev / loop0 . Vous pouvez le fsck , le monter, etc.

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

Démonter

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

Mise à jour pour Ubuntu 16.04: Avec la nouvelle, losetupceci est maintenant plus facile:

sudo losetup -Pf disk_image.raw

Voir le reste de la réponse pour les anciennes versions d'Ubuntu.

Une solution simple consiste à utiliser kpartx : il détermine la structure de la partition et mappe chaque unité sur un périphérique en mode bloc. Après cela, tout ce que vous avez à faire est de monter celui que vous voulez.

Ouvrez Terminal, localisez l’image disque et entrez la commande suivante:

$ 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

Cette créé loop0p1et loop0p2sous /dev/mapper. Dans la sortie, vous pouvez voir la taille des partitions, ce qui vous aide à les identifier. Vous pouvez monter celui que vous voulez avec:

$ sudo mount /dev/mapper/loop0p2 /mnt

Sinon, le périphérique de blocage est détecté par Nautilus et vous pouvez le monter à partir de la barre latérale:

Lorsque vous avez terminé, démontez ce que vous avez monté et supprimez le mappage de périphérique:

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

Edit : fonctionne avec util-linux> = 2.21 . Au moment de la rédaction, Ubuntu est livré avec la version 2.20 uniquement.

De l' homme perdant :

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

Donc juste courir

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

créer des nœuds de périphérique pour chaque partition de votre image disque sur le premier périphérique de boucle inutilisé et l’imprimer sur la sortie standard. Si vous utilisez un /dev/loop0périphérique, cela créera au moins /dev/loop0p1une capacité que vous pourrez monter comme d'habitude.

Essayez gnome-disk-image-mounter:

gnome-disk-image-mounter sda.img

Non sudorequis. Il sera monté à /media/your_user_name/partition_name, tout comme les clés USB.

losetup -P automatisation

losetup -Pest la meilleure méthode à partir d’Ubuntu 16.04, comme indiqué à l’ adresse https://askubuntu.com/a/496576/52975 , voici des fonctions à automatiser si nécessaire. Usage:

$ 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

La source:

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

module de boucle max_part config

Ceci est une méthode décente avant 16.04.

loop est un module de noyau, intégré au noyau dans Ubuntu 14.04.

Si vous le configurez correctement, Linux divise automatiquement les périphériques pour vous.

cat /sys/module/loop/parameters/max_part

indique le nombre de partitions que les looppériphériques peuvent générer.

C'est 0par défaut sur Ubuntu 14.04, c'est pourquoi aucune division automatique n'a lieu.

Pour le changer, on peut soit ajouter:

options loop max_part=31

dans un fichier /etc/modprobe, ou:

GRUB_CMDLINE_LINUX="loop.max_part=31"

à /etc/default/grubet ensuite sudo update-grub.

Comment définir un paramètre de module est également couvert à: Comment ajouter des paramètres de module au noyau?

Après un redémarrage, quand vous faites:

sudo losetup -f --show my.img

il monte l'image sur un /dev/loopXpériphérique et monte automatiquement les partitions sur des /dev/loopXpYpériphériques.

Donc, c'est la méthode la plus pratique si vous êtes prêt à redémarrer.

Voir également

• 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
• Monter une seule partition à partir de l'image du disque entier (périphérique)
• https://stackoverflow.com/questions/1419489/loopback-mounting-individual-partitions-from-within-a-file-that-contains-a-parti

Utilisez losetup pour attacher l’image entière du disque.

# sudo losetup /dev/loop2 sda.img

Ensuite, utilisez mdadm pour créer un périphérique md et des périphériques de blocage seront créés pour toutes les partitions.

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

Vous devriez maintenant voir les périphériques de partition.

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 manière la plus simple, à mon avis, utilise mount -o loop,offset=...comme mentionné dans cette réponse sur StackOverflow . L'idée est la suivante:

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

Cette méthode est préférable car elle ne nécessite pas la suppression du périphérique de boucle après le démontage de la partition montée.

Pour simplifier davantage la tâche (ce qui est nécessaire si vous le faites souvent), vous pouvez utiliser mon script mountimgpour tout faire à votre place. Obtenez-le simplement à partir de https://github.com/AlexanderAmelkin/mountimg et utilisez comme ceci:

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

Vous pouvez également spécifier le type de système de fichiers et toute autre option de montage supplémentaire si vous le souhaitez:

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

Quand vous avez fini avec la partition, umountil suffit de :

umount /media/sda_image