Inhaltsverzeichnis

Dateisystem-Images

Image auf einen USB-Stick schreiben

Download FreeBSD-ISO-IMAGES
- FreeBSD 14.0 ISO-IMAGES
  - FreeBSD 14.0 MEM-IMAGE
  - Writing an Image File to USB

> wget https://download.freebsd.org/releases/ISO-IMAGES/14.0/FreeBSD-14.0-RELEASE-amd64-memstick.img
> dd if=FreeBSD-14.0-RELEASE-amd64-memstick.img of=/dev/sdf bs=1M conv=sync

HDD-Image

siehe auch:

ein Image erstellen, welches zu Beginn nur 1MB groß ist aber bis zu 10GB groß werden kann:

> dd if=/dev/zero of=daten.hdd bs=1M count=1 seek=10240

so kann man ein LVM-Volumen von einem Image mounten:

http://www.hutsky.cz/blog/2014/06/mount-a-disk-image-containing-lvm/

FreeBSD-root-Image (mit UFS) einer VM vergrößern

FreeBSD-14.0-STABLE-Image (UFS-RAW) vergrößern

FreeBSD-root-Image (mit ZFS) einer VM vergrößern

ein Image mit einer Größe von 20GB anlegen:

> truncate -s 20G blk.img

ein bereits vorhandes Image um 10GB vergrößern:

> truncate -s +10G blk.img

ein bereits vorhandes Image auf 40GB vergrößern:

> truncate -s 40G blk.img

ZFS-Partitionen samt Größe anzeigen:

> zpool status
  pool: zroot
...
          vtbd0p3   ONLINE
...

> gpart list /dev/vtbd0
...
Consumers:
1. Name: vtbd0
   Mediasize: 42949672960 (40G)
...

> gpart show
=>      40  41942960  vtbd0  GPT  (40G) [CORRUPT]
        40      1024      1  freebsd-boot  (512K)
      1064       984         - free -  (492K)
      2048   4194304      2  freebsd-swap  (2.0G)
   4196352  37744640      3  freebsd-zfs  (18G)
  41940992      2008         - free -  (1.0M)

"freebsd-zfs" reparieren:

> gpart recover vtbd0
> gpart show
=>      40  41942960  vtbd0  GPT  (40G)
...

Wenn die Beschädigung zu schwerwiegend ist und gpart sie nicht beheben kann, dann ist hier Feierabend und die Partitionen müssen dann auf dem Image komplett neu angelegt werden.

"freebsd-zfs" vergrößern:

> gpart resize -i 3 vtbd0
> gpart show
> zpool online -e zroot /dev/vtbd0p3
> df -h

FreeBSD

Einhängen eines existierenden Abbildes unter FreeBSD

# mdconfig -a -t vnode -f diskimage -u 0
# mount /dev/md0 /mnt

Erstellen eines dateibasierten Laufwerks mit mdconfig

# dd if=/dev/zero of=newimage bs=1k count=5k
5120+0 records in
5120+0 records out

# mdconfig -a -t vnode -f newimage

# mdconfig -l
md0

# bsdlabel -w md0 auto
file -s /dev/md0a

# newfs md0a
/dev/md0a: 5.0MB (10224 sectors) block size 16384, fragment size 2048
        using 4 cylinder groups of 1.25MB, 80 blks, 192 inodes.
super-block backups (for fsck -b #) at:
 160, 2720, 5280, 7840

# mount /dev/md0a /mnt

# df /mnt
Filesystem 1K-blocks Used Avail Capacity  Mounted on
/dev/md0a       4710    4  4330     0%    /mnt

Mit mdmfs ein dateibasiertes Dateisystem erstellen

# dd if=/dev/zero of=newimage bs=1k count=5k
5120+0 records in
5120+0 records out
# mdmfs -F newimage -s 5m md0 /mnt
# df /mnt
Filesystem 1K-blocks Used Avail Capacity  Mounted on
/dev/md0        4718    4  4338     0%    /mnt

Linux

http://www.andremiller.net/content/mounting-hard-disk-image-including-partitions-using-linux

ohne OffSet

einfach als LOOP mounten:

> mount -t ext4 -o ro,loop /var/tmp/disk01.hdd /mnt

mit OffSet

erstmal den OffSet ermitteln

> parted /var/tmp/disk01.hdd

hier die Darstellungseinheit festlegen

(parted) unit
Unit?  [compact]? B

Partitionen anzeigen:

(parted) print
...
Number  Start        End           Size         Type     File system  Flags
 1      32256B       106928639B    106896384B   primary  ext3         boot
 2      106928640B   1184440319B   1077511680B  primary  linux-swap
 3      1184440320B  10256924159B  9072483840B  primary  ext3

In der Spalte "Start" stehen die gesuchten Werte für "OffSet"; "fdisk" würde hier "63" (512B-Blöcke) stehen haben.

mount mit OffSet:

> mount -o loop,ro,offset=32256 /var/tmp/disk01.hdd /mnt

sollte der OffSet zu groß sein (manche Tools können das nicht), dann kann man auch mit "dd" ein angepasstes Image generieren:

> dd if=/var/tmp/disk01.hdd of=/var/tmp/disk01_2.hdd bs=8 skip=1184440320 count=9072483840
> mount -t ext4 -o ro,loop /var/tmp/disk01_2.hdd /mnt

Variante 1 mit fdisk:

> fdisk -lu disk01.hdd
Units = sectors of 1 * 512 = 512 bytes
Device           Boot Start    End  Blocks Id System
disk01.hdd1         *    63 409247 204592+  6 FAT16

> mount -o loop,offset=$((512*63)) disk01.hdd /mnt

Variante 2 mit kpartx:

http://www.azertech.net/content/creating-disk-images

kpartx installieren:

> aptitude install kpartx
> man kpartx

Partition(en) anlegen:

> fdisk disk01.hdd
> fdisk -lu disk01.hdd

hier wird jede Partition auf dem Image auf ein lo-Dev gelegt:

> kpartx -av disk01.hdd
> kpartx -l disk01.hdd
loop0 : 0 16777089 /dev/loop0 63

lo-Dev formatieren:

> mkfs -t ext4 /dev/mapper/loop0p1

mounten

> mount -o loop /dev/mapper/loop0p1 /mnt/

Daten drauf packen:

> tar xzf ubuntu_1004.tgz -C /mnt/

alles wieder lösen:

> umount /mnt/
> kpartx -dv disk01.hdd

Variante 3 mit losetup:

nachsehen, welches lo-Dev als erstes freies vorliegt:

> losetup -f
/dev/loop0

Image an ein lo-Dev binden und dann partitionieren:

> losetup /dev/loop0 disk01.hdd
> fdisk /dev/loop0

lo-Dev wieder lösen, damit es mit OffSet erneut gebunden werden kann

> losetup -d /dev/loop0

das Image mit OffSet an das lo-Dev mounten, also nur die Partition:

> losetup -o $OFFSET /dev/loop0 disk01.hdd

das Gerät an ein Verzeichnis mounten, damit man Daten reinschreiben kann:

> mount /dev/loop0 mnt

alles wieder lösen:

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

QEMU QCOW Image

Image-Format ermitteln:

> file image.hdd
image.hdd: QEMU QCOW Image (unknown version)

> modprobe nbd max_part=63
> qemu-nbd -c /dev/nbd0 image.hdd
> mount /dev/nbd0p1 /mnt/
> ls /mnt/
> umount /mnt/
> qemu-nbd -d /dev/nbd0

Live-CD

initrd

https://wiki.ubuntu.com/CustomizeLiveInitrd

eine neue initrd bauen

Sollten in dieser initrd auch nicht die benötigten Treiber drin sein, dann müssen wir uns eine eigene initrd bauen.

Hier wird beschrieben, wie man sich eine neue initrd baut:

http://wiki.ubuntuusers.de/PXE-Boot#Ubuntu-Diskless

bevor wir jetzt unsere neue initrd bauen, kontrollieren wir noch eine Option in zwei Dateien:

/etc/initramfs-tools/initramfs.conf
- MODULES=list
- BOOT=local
/etc/initramfs-tools/update-initramfs.conf
- update_initramfs=yes

wir müssen die Option auf "list" stellen, um die gewünschten Treiber hier angeben zu können:

# vi /etc/initramfs-tools/modules

jetzt können wir uns die neue initrd bauen:

# mkinitramfs -o /tmp/initrd.img

eine vorhandene Ubuntu-initrd (ab Ubuntu 9.10) modifizieren

entpacken

# mkdir initrd
# cd initrd
# lzma -dc -S .lz ../initrd.lz | cpio -imvd --no-absolute-filenames

Bootprozess modifizieren

Dazu müssen die Dateien im Verzeichnis usr/share/initramfs-tools/scripts/casper-bottom/* verändert werden:

usr/share/initramfs-tools/scripts/casper
usr/share/initramfs-tools/scripts/casper-bottom/10adduser

Ubuntu 14.04:

> gzip -dc /boot/initrd.img-4.4.0-83-generic | cpio -id
> zcat /boot/initrd.img-4.4.0-83-generic | cpio -idmv

verpacken

Variante 1:

# mv -v ../initrd.lz ../inird.lz.orig
# find . | cpio --quiet --dereference -o -H newc | lzma -7 > ../initrd.lz

Variante 2:

# cd ..
# chroot initrd/
# mkinitramfs -o /initrd.gz 2.6.38-11-generic
# exit
# gzip -dc initrd/initrd.gz | sudo lzma -7 > initrd.lz

initrd von Ubuntu 13.04

Auch die initrd's der alten Ubuntu-Versionen von vor 9.10 können so bearbeitet werden.

auspacken:

> mkdir /tmp/initrd
> cd /tmp/initrd
> zcat /boot/initrd.img-3.8.0-19-generic | cpio -imvd --no-absolute-filenames

einpacken:

> cd /tmp/initrd
> find . | cpio --quiet --dereference -o -H newc | gzip -9 > ~/new-initrd.gz

Slackware-initrd

http://www.linuxforen.de/forums/showthread.php?t=118001

entpacken:

> zcat initrd.img > initrd.img.entpackt
> mount -o loop,rw initrd.img.entpackt /mnt/initrd

Im Verzeichnis lib/ sollten dann ein paar Kernel Module liegen. Dort kopierst du deinen Treiber hin. Zudem mußt du in der linuxrc einen insmod /lib/dein-raid-treiber.o hinzufügen.

danach:

> umount /mnt/initrd
> gzip -9 initrd.img.entpackt
> mv initrd.img initrd.img.old
> mv initrd.img.entpackt initrd.img

Nicht vergessen den lilo aufzurufen, falls dieser verwendet wird.

squash-Image

entpacken

# aptitude install squashfs-tools genisoimage
# unsquashfs filesystem.squashfs
# cd squashfs-root
# ...

verpacken

# ...
# cd ..
# rm -v filesystem.squashfs
# mksquashfs squashfs-root filesystem.squashfs -nolzma
# printf $(sudo du -sx --block-size=1 squashfs-root | cut -f1) > filesystem.size

Cloud-Images

Cloud-Images saugen

Leider hat dieses Image keine Partition.

> wget https://cloud-images.ubuntu.com/bionic/current/bionic-server-cloudimg-amd64.tar.gz
> tar xzf bionic-server-cloudimg-amd64.tar.gz
> fdisk -l bionic-server-cloudimg-amd64.img
> mount bionic-server-cloudimg-amd64.img /mnt

das Image auf 20GB vergrößern:

> qemu-img resize -f raw bionic-server-cloudimg-amd64.img 20G

umwandeln in das platzsparende QCOW2-Format:

> qemu-img convert -p -f raw -O qcow2 bionic-server-cloudimg-amd64.img bionic-server-cloudimg-amd64.qcow2

How to mount a qcow2 disk image:

> modprobe nbd max_part=8
> qemu-nbd --connect=/dev/nbd0 bionic-server-cloudimg-amd64.qcow2
> fdisk -l /dev/nbd0
> mount /dev/nbd0p1 /mnt/

> ls -lha /mnt/

> umount /mnt/somepoint/
> qemu-nbd --disconnect /dev/nbd0
> rmmod nbd

Cloud-Images bauen

Leider hat dieses Image keinen OS-Kernel.

Bis Ubuntu 16.04 war der Partitionstyp DOS mit MBR. Seit Ubuntu 18.04 ist das Image vom Partitionstyp GPT im EFI-Format.

Vorbereitungen für das erzeugen eines Images:

> wget https://cloud-images.ubuntu.com/bionic/current/bionic-server-cloudimg-amd64-root.tar.xz
> apt install xz-utils libguestfs-tools
> xz -d bionic-server-cloudimg-amd64-root.tar.xz

Der User, der die Konvertierung durchführen soll, muß in der Gruppe "kvm" sein bzw. auf das Gerät "/dev/kvm" zugreifen können:

> id

Jetzt muß überprüft werden, ob noch der DASH-Bug behoben werden muss, wenn diese Datei nicht existiert:

> cat /usr/lib/x86_64-linux-gnu/guestfs/supermin.d/zz-dash-packages

dann muss man sie anlegen:

> echo dash > /usr/lib/x86_64-linux-gnu/guestfs/supermin.d/zz-dash-packages

sonst funktioniert es nicht.

so erzeugen wir unterschiedliche Images aus dem TAR-Paket:

> virt-make-fs -t ext4 --label root -s 20G bionic-server-cloudimg-amd64-root.tar bionic-server-cloudimg-amd64-root.hdd
> virt-make-fs -t ext4 --label root -s 20G --format=qcow2 bionic-server-cloudimg-amd64-root.tar bionic-server-cloudimg-amd64-root.qcow2
> virt-make-fs -t ext4 --label root -s 20G --format=qcow2 --partition=mbr bionic-server-cloudimg-amd64-root.tar bionic-server-cloudimg-amd64-root.qcow2

später kann man das erzeugte Image aber auch noch nach belieben in andere Formate konvertieren:

> apt install qemu-utils
> qemu-img convert -p -f qcow2 -O raw bionic-server-cloudimg-amd64.qcow2 bionic-server-cloudimg-amd64.img
> qemu-img info bionic-server-cloudimg-amd64.img

> qemu-img info bionic-server-cloudimg-amd64-root.qcow2

so kann man ein RAW-Image einhängen:

> apt install fdisk
> fdisk -l bionic-server-cloudimg-amd64-root.hdd
Festplatte bionic-server-cloudimg-amd64-root.hdd: 1 GiB, 1073741824 Bytes, 2097152 Sektoren
Einheiten: Sektoren von 1 * 512 = 512 Bytes
Sektorgröße (logisch/physikalisch): 512 Bytes / 512 Bytes
E/A-Größe (minimal/optimal): 512 Bytes / 512 Bytes
Festplattenbezeichnungstyp: dos
Festplattenbezeichner: 0xe76bc6c9

Gerät                                  Boot Anfang    Ende Sektoren   Größe Kn Typ
bionic-server-cloudimg-amd64-root.hdd1         128 2097024  2096897 1023,9M 83 Linux

als OFFSET muss die "128" aus der Spalte "Anfang" verwendet werden ("128" → 128 Blöcke / 1Block=512Byte):

> mount -o loop,offset=$((512*128)) bionic-server-cloudimg-amd64-root.hdd /mnt

HDD-Image bootfähig machen

Bis Ubuntu 16.04 war der Partitionstyp DOS mit MBR. Seit Ubuntu 18.04 ist das Image vom Partitionstyp GPT im EFI-Format.

bootfähiges HDD-Image erzeugen

benötigte Werkzeuge installieren (meistens sind sie bereits installiert):

> apt install wget tar xz-utils

Wir holen uns ein (neues/aktuelles) TAR-GZ-Paket mit vollständigem Root-File-System (inklusive OS-Kernel) aus dem Internet. Dann bauen wir uns ein bootfähiges Image auf einer RAW-Partition (DOS-Partition) und MBR.

in diesem Paket sind alle Dateien für ein lauffähiges Betriebssystem drin:

> wget --no-check-certificate https://cloud-images.ubuntu.com/bionic/current/bionic-server-cloudimg-amd64.tar.gz
> tar xzf bionic-server-cloudimg-amd64.tar.gz
> ls -lha bionic-server-cloudimg-amd64.img
-rw-r--r-- 1 fritz fritz 1,1G Sep 21 15:29 bionic-server-cloudimg-amd64.img

jetzt bauen wir uns ein leeres HDD-Image (hier 20GB groß) mit einer RAW-Partition (DOS-Partition) und MBR:

> mkdir /tmp/img
> virt-make-fs -t ext4 --label root -s 20G --format=raw --partition=mbr /tmp/img bionic-server-cloudimg-amd64.hdd
> ls -lha bionic-server-cloudimg-amd64.hdd
-rw-r--r-- 1 root root 20G Sep 21 19:35 bionic-server-cloudimg-amd64.hdd

> mount bionic-server-cloudimg-amd64.img /mnt1
> losetup -a
/dev/loop0: [64770]:561321382 (/home/manfred/Downloads/bionic-server-cloudimg-amd64.img)

> losetup -fP bionic-server-cloudimg-amd64.hdd
> losetup -a
/dev/loop1: [64770]:561328298 (/home/manfred/Downloads/bionic-server-cloudimg-amd64.hdd)
/dev/loop0: [64770]:561321382 (/home/manfred/Downloads/bionic-server-cloudimg-amd64.img)

> ls -lha /dev/loop1*
brw-rw---- 1 root disk   7, 1 Sep 21 15:58 /dev/loop1
brw-rw---- 1 root disk 259, 0 Sep 21 15:58 /dev/loop1p1

> mount /dev/loop1p1 /mnt0
> df -h
...
/dev/loop0              991M    922M   54M   95% /mnt1
/dev/loop1p1             20G    673M   18G    4% /mnt0

> cd /mnt1/
> cp -a * /mnt0/

vergleichen, ob alle Daten rübergekommen sind bzw. beide gleich sind:

> du -sm /mnt1/ /mnt0/
917     /mnt1/
917     /mnt0/

> find /mnt1/ | wc -l ; find /mnt0/ | wc -l
66670
66670

fertig

> umount /mnt1/

Den Mount-Point "/mnt0/" brauchen wir noch, weil dort ja der Grub noch das Image bootfest machen soll.

Grub auf dem Image ausführen (bootfähig machen)

chroot-Methode

> mount -B /proc/ /mnt0/proc/
> mount -B /sys/ /mnt0/sys/
> mount -B /dev/ /mnt0/dev/
> mount -B /dev/pts/ /mnt0/dev/pts/

> chroot /mnt0 /bin/bash
> df -h
Filesystem      Size  Used Avail Use% Mounted on
/dev/loop1p1     20G  961M   18G   6% /
udev             16G     0   16G   0% /dev

damit er das Betriebsystem aus dem Host-System nicht findet:

> echo "GRUB_DISABLE_OS_PROBER=true" >> /etc/default/grub

WICHTIG! hier muss das Gerät /dev/loop1 ohne p1 angegeben werden:

> grub-install /dev/loop1
Installing for i386-pc platform.
Installation finished. No error reported.

> update-grub2
Generating grub configuration file ...
Found linux image: /boot/vmlinuz-4.15.0-34-generic
Found initrd image: /boot/initrd.img-4.15.0-34-generic
done

fertig

> umount /mnt0/dev/pts/
> umount /mnt0/dev/
> umount /mnt0/sys/
> umount /mnt0/proc/
> umount /mnt0/
> losetup -a
/dev/loop1: [64770]:561328298 (/home/manfred/Downloads/xenial-server-cloudimg-amd64-root.hdd)

> losetup -d /dev/loop1

Vorbereitung für VirtualBox:

> mv xenial-server-cloudimg-amd64-root.img test01.hdd
> qemu-img convert -p -f raw -O qcow2 test01.hdd test01.qcow2
    (100.00/100%)

> ls test01.qcow2
-rw-r--r-- 1 fritz fritz 1,1G Sep 21 16:28 test01.qcow2

Leider bleibt die VM (in VirtualBox) beim booten stehen und kann den Bootvorgang nicht abschließen, so das ich kein Prompt bekomme…

Skripte für das mounten von HDD-Images mit Partitionen

/root/bin/mount_img.sh

#/bin/bash
 
#==============================================================================#
#
# /root/bin/mount_img.sh /var/lib/uvtool/libvirt/images/x-uvt-b64-Y29tLnVidW50dS5jbG91ZDpzZXJ2ZXI6MTYuMDQ6YW1kNjQgMjAxODA5PWE=_bionic.raw /mnt
#
#==============================================================================#
 
VERSION="v2018092100"
 
 
SKRIPTVERZ="$(dirname ${0})"
#. ${SKRIPTVERZ}/mount_img.cfg
 
# mount -o loop,offset=$((512*2048)) /var/lib/uvtool/libvirt/images/x-uvt-b64-Y29tLnVidW50dS5jbG91ZDpzZXJ2ZXI6MTYuMDQ6YW1kNjQgMjAxODA5MTI=_xenial.raw /mnt/
IMAGE_NAME="${1}"
MOUNT_POINT="${2}"
 
#------------------------------------------------------------------------------#
### Parameterüberprüfung
 
if [ ! -e "${IMAGE_NAME}" ] ; then
        echo "Das Image '${IMAGE_NAME}' wurde nicht gefunden..."
        exit 1
fi
 
if [ ! -d "${MOUNT_POINT}" ] ; then
        echo "Der Mount-Point '${MOUNT_POINT}' ist bereits belegt..."
        exit 1
fi
 
BELEGT="$(df -h ${MOUNT_POINT} | tail -n1 | awk '{print $1}' | fgrep loop)"
if [ "x${BELEGT}" != "x" ] ; then
        echo "Der Mount-Point '${MOUNT_POINT}' ist bereits belegt: '${BELEGT}'"
        exit 1
fi
 
#------------------------------------------------------------------------------#
### mount
 
losetup -fP "${IMAGE_NAME}"
LO_DEV="$(losetup -a | fgrep "${IMAGE_NAME}" | awk -F':' '{print $1}')"
ls -lha ${LO_DEV}*
mount ${LO_DEV}p1 ${MOUNT_POINT}
 
#------------------------------------------------------------------------------#
### Bind-Mount
 
mount -B /proc/ /${MOUNT_POINT}/proc/
mount -B /sys/ /${MOUNT_POINT}/sys/
mount -B /dev/ /${MOUNT_POINT}/dev/
mount -B /dev/pts/ /${MOUNT_POINT}/dev/pts/

</hidden>

/root/bin/umount_img.sh

#/bin/bash
 
#==============================================================================#
#
# /root/bin/umount_img.sh /var/lib/uvtool/libvirt/images/x-uvt-b64-Y29tLnVidW50dS5jbG91ZDpzZXJ2ZXI6MTYuMDQ6YW1kNjQgMjAxODA5PWE=_bionic.raw /mnt
#
#==============================================================================#
 
VERSION="v2018092100"
 
 
SKRIPTVERZ="$(dirname ${0})"
#. ${SKRIPTVERZ}/mount_img.cfg
 
# umount /mnt/
IMAGE_NAME="${1}"
MOUNT_POINT="${2}"
 
#------------------------------------------------------------------------------#
### Parameterüberprüfung
 
#if [ ! -d "${MOUNT_POINT}" ] ; then
#       echo "Der Mount-Point '${MOUNT_POINT}' wurde nicht gefunden..."
#       exit 1
#fi
 
BELEGT="$(df -h ${MOUNT_POINT} | tail -n1 | awk '{print $1}' | fgrep loop)"
if [ "x${BELEGT}" = "x" ] ; then
        echo "Der Mount-Point '${MOUNT_POINT}' ist nicht in Nutzung..."
        exit 1
fi
 
#------------------------------------------------------------------------------#
### umount
 
umount /${MOUNT_POINT}/dev/pts/
umount /${MOUNT_POINT}/dev/
umount /${MOUNT_POINT}/sys/
umount /${MOUNT_POINT}/proc/
umount /${MOUNT_POINT}/
 
LO_DEV="$(losetup -a | fgrep "${IMAGE_NAME}" | awk -F':' '{print $1}')"
losetup -d ${LO_DEV}
ls -lha ${LO_DEV}*

</hidden>

/root/bin/mach_img.sh

#!/bin/bash
 
#==============================================================================#
#
# Dieses Skript baut aus den Image-Daten (z.B.: bionic-server-cloudimg-amd64.tar.gz)
# ein DOS-Image mit MBR (z.B.: bionic-server-cloudimg-amd64.hdd).
#
# /root/bin/mach_img.sh bionic-server-cloudimg-amd64.tar.gz bionic-server-cloudimg-amd64.hdd 20G
#
#==============================================================================#
 
VERSION="v2018092100"
 
 
SKRIPTVERZ="$(dirname ${0})"
Z="$(head -c 100 /dev/urandom | base64 | tr -d '\n' | tr -cd '[:alnum:]' | cut -b-12)"
 
# ${0} bionic-server-cloudimg-amd64.tar.gz bionic-server-cloudimg-amd64.hdd 20G
DATEN_NAME="${1}"       # bionic-server-cloudimg-amd64.tar.gz (bionic-server-cloudimg-amd64.img)
IMAGE_NAME="${2}"       # neues Image, z.B.: bionic-server-cloudimg-amd64.hdd
IMAGE_GR="${3}"         # (virt-make-fs): gewünschte Größe des neuen HDD-Images
 
#------------------------------------------------------------------------------#
### Parameterüberprüfung
 
if [ ! -e "${DATEN_NAME}" ] ; then
        echo "Das Image '${IMAGE_NAME}' wurde nicht gefunden..."
        exit 1
fi
 
if [ -e "${IMAGE_NAME}" ] ; then
        echo "Das Image '${IMAGE_NAME}' existiert bereits..."
        exit 1
fi
 
if [ "x${IMAGE_GR}" = x ] ; then
        IMAGE_GR="20G"  # Standardgröße des neuen Images, wenn nichts angegeben wurde
fi
 
#------------------------------------------------------------------------------#
### Vorbereitungen
 
mkdir -v /tmp/img_${Z}/
cp ${DATEN_NAME} /tmp/img_${Z}/
 
cd /tmp/img_${Z}/
 
 
Dz_NAME="$(basename ${DATEN_NAME})"
D_NAME="$(echo "${Dz_NAME}" | sed 's/[.]tar[.]gz$/.img/')"
if [ "${Dz_NAME}" = "${D_NAME}" ] ; then
        echo "Die Datei '${Dz_NAME}' liegt nicht im Format '*.tar.gz' vor..."
        exit 1
else
        # bionic-server-cloudimg-amd64.tar.gz -> bionic-server-cloudimg-amd64.img
        tar xvzf ${Dz_NAME}
fi
 
 
mkdir -p /tmp/img_${Z}/img
echo "virt-make-fs -t ext4 --label root -s ${IMAGE_GR} --format=raw --partition=mbr -> ${IMAGE_NAME}"
virt-make-fs -t ext4 --label root -s ${IMAGE_GR} --format=raw --partition=mbr /tmp/img_${Z}/img ${IMAGE_NAME}
 
#------------------------------------------------------------------------------#
### Datenübertragung
 
mkdir -pv /mnt0
mkdir -pv /mnt1
 
mount ${D_NAME} /mnt0 || exit 2
 
losetup -fP "${IMAGE_NAME}"
LO_DEV="$(losetup -a | fgrep "${IMAGE_NAME}" | awk -F':' '{print $1}')"
if [ "x${LO_DEV}" = x ] ; then
        echo "Es konnte kein Gerät erzeugt werden: '${LO_DEV}'"
        exit 11
fi
ls -lha ${LO_DEV}*
 
mount ${LO_DEV}p1 /mnt1 || exit 3
 
cd -
cd /mnt0/ || exit 4
cp -a * /mnt1/
 
cd -
umount /mnt0/
umount /mnt1/
 
LO_DEV="$(losetup -a | fgrep "${IMAGE_NAME}" | awk -F':' '{print $1}')"
if [ "x${LO_DEV}" != x ] ; then
        for l in ${LO_DEV}
        do
                losetup -d ${l}
        done
fi
ls -lha ${LO_DEV}*
 
mv /tmp/img_${Z}/${IMAGE_NAME} .
rm -fr /tmp/img_${Z}/
 
#------------------------------------------------------------------------------#
### mount + update-grub2
 
/root/bin/mount_img.sh ${IMAGE_NAME} /mnt1
 
LO_DEV="$(losetup -a | fgrep "${IMAGE_NAME}" | awk -F':' '{print $1}')"
if [ "x${LO_DEV}" = x ] ; then
        echo "Leider konnte keine gebundene loop-Gerätedatei gefunden werden..."
else
        echo "GRUB_DISABLE_OS_PROBER=true" >> /mnt1/etc/default/grub
        echo "grub-install ${LO_DEV}" | chroot /mnt1 /bin/bash
        echo "update-grub2" | chroot /mnt1 /bin/bash
fi
sync
sleep 5
 
/root/bin/umount_img.sh ${IMAGE_NAME} /mnt1

</hidden>