Linux - comment formater plusieurs systèmes de fichiers dans un seul fichier?

J'ai besoin de créer une image disque avec deux systèmes de fichiers vides. Je l'ai créé en utilisant

dd if=/dev/zero of=./disk.img bs=1MiB count=1024

Ensuite, j'ai créé 2 partitions principales en utilisant fdisk disk.img; l'un est FAT32 et l'autre est EXT3. Maintenant, je dois formater les deux partitions afin de créer des systèmes de fichiers à monter en tant que -o loop devices. Mais je ne comprends pas comment les formater? Je ne peux pas utiliser mkfs.vfatsur disk.img. Je suis donc totalement confus.

SOLUTION: Grâce à la réponse de @ pjc50, j'ai trouvé une solution très simple:

sudo aptitude install multipath-tools
sudo kpartx -a disk.img   #it maps (mounts) found partitions to /dev/mapper/loop...
sudo mkfs.vfat -F 32 -n boot /dev/mapper/loop0p1
sudo mkfs.ext3 -L rootfs /dev/mapper/loop0p2

Un inconvénient de cette solution est l'exigence de droits de superutilisateur.

Il semble que vous pouvez utiliser les outils kpartx: http://robert.penz.name/73/kpartx-a-tool-for-mounting-partitions-within-an-image-file/

Kpartx peut être utilisé pour configurer les mappages de périphériques pour les partitions de tout périphérique de bloc partitionné. Il fait partie des outils multivoie Linux. Avec kpartx -l fichier image, vous obtenez un aperçu des partitions dans le fichier image et avec kpartx -a fichier image, les partitions seront accessibles via / dev / mapper / loop0pX (X est le numéro de la partition). Vous pouvez le monter maintenant avec la boucle mount / dev / mapper / loop0pX / mnt / -o, ro. Après le démontage, vous pouvez déconnecter les périphériques du mappeur avec le fichier image kpartx -d.

Vous pouvez le faire en montant d'abord vos partitions à l' /dev/loop?aide losetupde l' -ooption permettant de spécifier un décalage approprié pour votre partition. Le décalage peut être calculé sur la base de la sortie de fdisk -l disk.img( start_sector * sector_size).

Par exemple:

losetup -o32256 /dev/loop1 ./disk.img   # mount first partition

Une fois monté, vous pouvez ensuite procéder au formatage de la partition en utilisant mkfs.*:

mkfs.vfat -F32 /dev/loop1

Pour plus de détails et d'exemples, consultez les articles suivants:

• http://wiki.osdev.org/Loopback_Device#Mounting
• http://web2.clarkson.edu/projects/itl/honeypot/ddtutorial.txt
• http://wiki.eeeuser.com/howtocustomrestoreimage:pt2mkcustomimage

J'irais avec les outils que j'ai en tête:

• créer une nouvelle machine virtuelle dans Virtualbox avec un disque, ce serait généralement /dev/sda
• démarrer dans la machine virtuelle avec un CD Live GParted
• partitionnez et formatez le disque dans la VM selon vos besoins (2 partitions, différents systèmes de fichiers, etc.)
• puis utiliser ddpour exporter /dev/sdavers un fichier

Avec une supposition éclairée, cela prendrait environ 15 minutes.

Exécution minimale sfdisk+ mke2fsexemple sanssudo

Dans cet exemple, nous allons créer, sans sudoou setsuid, un fichier image contenant deux partitions ext2, chacune remplie de fichiers provenant d'un répertoire hôte.

Nous utiliserons ensuite sudo losetupjuste pour monter les partitions pour tester que le noyau Linux peut réellement les lire comme expliqué sur: /programming/1419489/how-to-mount-one-partition-from-an-image -file-that-contains-multiple-partitions / 39675265 # 39675265

Pour plus de détails, voir:

• sfdisk: traite de la table de partition: Comment créer et formater une partition en utilisant un script bash?
• mke2fs: traite du formatage EXT des partitions: Comment créer une image ext2 sans droits de superutilisateur?

L'exemple:

#!/usr/bin/env bash

# Input params.
root_dir_1=root1
root_dir_2=root2
partition_file_1=part1.ext2
partition_file_2=part2.ext2
partition_size_1_megs=32
partition_size_2_megs=32
img_file=img.img
block_size=512

# Calculated params.
mega="$(echo '2^20' | bc)"
partition_size_1=$(($partition_size_1_megs * $mega))
partition_size_2=$(($partition_size_2_megs * $mega))

# Create a test directory to convert to ext2.
mkdir -p "$root_dir_1"
echo content-1 > "${root_dir_1}/file-1"
mkdir -p "$root_dir_2"
echo content-2 > "${root_dir_2}/file-2"

# Create the 2 raw ext2 images.
rm -f "$partition_file_1"
mke2fs \
  -d "$root_dir_1" \
  -r 1 \
  -N 0 \
  -m 5 \
  -L '' \
  -O ^64bit \
  "$partition_file_1" \
  "${partition_size_1_megs}M" \
;
rm -f "$partition_file_2"
mke2fs \
  -d "$root_dir_2" \
  -r 1 \
  -N 0 \
  -m 5 \
  -L '' \
  -O ^64bit \
  "$partition_file_2" \
  "${partition_size_2_megs}M" \
;

# Default offset according to
part_table_offset=$((2**20))
cur_offset=0
bs=1024
dd if=/dev/zero of="$img_file" bs="$bs" count=$((($part_table_offset + $partition_size_1 + $partition_size_2)/$bs)) skip="$(($cur_offset/$bs))"
printf "
type=83, size=$(($partition_size_1/$block_size))
type=83, size=$(($partition_size_2/$block_size))
" | sfdisk "$img_file"
cur_offset=$(($cur_offset + $part_table_offset))
# TODO: can we prevent this and use mke2fs directly on the image at an offset?
# Tried -E offset= but could not get it to work.
dd if="$partition_file_1" of="$img_file" bs="$bs" seek="$(($cur_offset/$bs))"
cur_offset=$(($cur_offset + $partition_size_1))
rm "$partition_file_1"
dd if="$partition_file_2" of="$img_file" bs="$bs" seek="$(($cur_offset/$bs))"
cur_offset=$(($cur_offset + $partition_size_2))
rm "$partition_file_2"

# Test the ext2 by mounting it with sudo.
# sudo is only used for testing, the image is completely ready at this point.

# losetup automation functions from:
# /programming/1419489/how-to-mount-one-partition-from-an-image-file-that-contains-multiple-partitions/39675265#39675265
loop-mount-partitions() (
  set -e
  img="$1"
  dev="$(sudo losetup --show -f -P "$img")"
  echo "$dev" | sed -E 's/.*[^[:digit:]]([[:digit:]]+$)/\1/g'
  for part in "${dev}p"*; do
    if [ "$part" = "${dev}p*" ]; then
      # Single partition image.
      part="${dev}"
    fi
    dst="/mnt/$(basename "$part")"
    echo "$dst" 1>&2
    sudo mkdir -p "$dst"
    sudo mount "$part" "$dst"
  done
)
loop-unmount-partitions() (
  set -e
  for loop_id in "$@"; do
    dev="/dev/loop${loop_id}"
    for part in "${dev}p"*; do
      if [ "$part" = "${dev}p*" ]; then
        part="${dev}"
      fi
      dst="/mnt/$(basename "$part")"
      sudo umount "$dst"
    done
    sudo losetup -d "$dev"
  done
)

loop_id="$(loop-mount-partitions "$img_file")"
sudo cmp /mnt/loop0p1/file-1 "${root_dir_1}/file-1"
sudo cmp /mnt/loop0p2/file-2 "${root_dir_2}/file-2"
loop-unmount-partitions "$loop_id"

Testé sur Ubuntu 18.04. GitHub en amont .