nbd - Network Block Device

#!/bin/bash

set -euo pipefail
SIZE=5G

echo -e "\n\tUsage:\t sudo -s $(basename "$0") [Size]"
[ "$(id -u)" -ne 0 ] && { echo -e "\troot erforderlich.\n"; exit 1; }

# Prüfen, ob Imagegröße übergeben wurde
[ "$#" -eq 1 ] && { SIZE="$1"; }

echo -e "\tErzeuge Image mit $SIZE.\n"

IMAGE="image-${SIZE}.$(date +%Y%m%d-%H%M%S).qcow2"

# NBD-Modul laden
if ! modprobe nbd; then
    echo "Fehler: Kernelmodul nbd konnte nicht geladen werden."
    exit 1
fi

NBD=""

for dev in /dev/nbd[0-9]; do
    [[ -e "$dev" ]] || continue

    if [[ ! -f "/sys/block/${dev##*/}/pid" ]] || \
       [[ "$(cat "/sys/block/${dev##*/}/pid" 2>/dev/null || echo 0)" == "0" ]]; then
        NBD="$dev"
        break
    fi
done

if [[ -z "$NBD" ]]; then
    echo "Fehler: Kein freies NBD-Device gefunden."
    exit 1
fi

PART="${NBD}p1"

echo -e "Verwende freies NBD-Device: $NBD"


# Image erzeugen
echo "Erzeuge Image: $IMAGE"
qemu-img create -f qcow2 "$IMAGE" "$SIZE"

# NBD verbinden
echo "Verbinde $IMAGE mit $NBD"
qemu-nbd --connect="$NBD" "$IMAGE"

cleanup() {
    if [[ -b "$NBD" ]]; then
        qemu-nbd --disconnect "$NBD" >/dev/null 2>&1 || true
    fi
}

trap cleanup EXIT

# Partitionstabelle und Partition erzeugen
echo "Erzeuge MBR-Partitionstabelle..."
parted "$NBD" --script \
    mklabel msdos \
    mkpart primary ext4 1MiB 100% \
    set 1 boot on

# Kernel/udev über neue Partition informieren
partprobe "$NBD" || true
udevadm settle

# Warten, bis Partition vorhanden ist
for i in {1..10}; do
    [[ -b "$PART" ]] && break
    sleep 1
done

if [[ ! -b "$PART" ]]; then
    echo "Fehler: Partition $PART wurde nicht angelegt."
    exit 1
fi

# Dateisystem erstellen
echo "Formatiere $PART als ext4..."
mkfs.ext4 "$PART"

echo "Fertig."
echo "Image:     $IMAGE"
echo "Größe:     $SIZE"
echo "Partition: $PART"

#!/bin/bash

# Festplatte wird als Network Block Device (Kernelmodul nbd) bereitgestellt
# und mit chroot zugegriffen.

MOUNTPOINT="/mnt/rootfs"
IMAGE="rootfs.qcow2"
NBD="/dev/nbd0"

echo "Was möchtest du tun?"
echo "1) Image öffnen"
echo "2) Image schließen"
read -p "Auswahl [1-2]: " AUSWAHL

# NBD-Modul laden, falls noch nicht vorhanden
if ! lsmod | grep -q "^nbd"; then
    echo "Lade Kernelmodul nbd mit max 2 Partitionen pro Network Block Device (also ${NBD}p1, ${NBD}p2)."
    sudo modprobe nbd max_part=2

    if ! lsmod | grep -q "^nbd"; then
        echo "Fehler: Modul nbd konnte nicht geladen werden."
        exit 1
    fi
fi


case $AUSWAHL in
    1)
        echo "Image wird geöffnet..."

        sudo qemu-nbd --connect=$NBD $IMAGE
        sudo mount ${NBD}p1 $MOUNTPOINT

        sudo mount --bind /proc $MOUNTPOINT/proc
        sudo mount --bind /sys $MOUNTPOINT/sys
        sudo mount --bind /dev $MOUNTPOINT/dev

	#ggf. resolv.conf kopieren für Internet
	#sudo cp /etc/resolv.conf $MOUNTPOINT/etc/resolv.conf

        # Falls UEFI benötigt wird:
        # sudo mount --bind /run $MOUNTPOINT/run

        echo ""
        echo "Image eingebunden."
        echo "Chroot starten mit:"
        echo "sudo chroot $MOUNTPOINT"
        ;;
        
    2)
        echo "Image wird geschlossen..."

        sudo umount $MOUNTPOINT/dev 2>/dev/null
        sudo umount $MOUNTPOINT/sys 2>/dev/null
        sudo umount $MOUNTPOINT/proc 2>/dev/null

        # Falls /run eingebunden wurde:
        # sudo umount $MOUNTPOINT/run 2>/dev/null

        sudo umount $MOUNTPOINT 2>/dev/null

        sudo qemu-nbd --disconnect ${NBD}p1
        sudo qemu-nbd --disconnect $NBD

        echo "Image ausgehängt."
        ;;

    *)
        echo "Ungültige Auswahl."
        exit 1
        ;;
esac

#!/bin/bash

MOUNTPOINT="/mnt/rootfs"
IMAGE="rootfs.ubuntu.qcow2"
NBD="/dev/nbd0"



# NBD-Modul laden, falls noch nicht vorhanden
if ! lsmod | grep -q "^nbd"; then
    echo "Lade Kernelmodul nbd mit max 2 Partitionen pro Network Block Device (also ${NBD}p1, ${NBD}p2)."
    sudo modprobe nbd max_part=2

    if ! lsmod | grep -q "^nbd"; then
        echo "Fehler: Modul nbd konnte nicht geladen werden."
        exit 1
    fi
fi





# 1. Image erzeugen und einhängen
qemu-img create -f qcow2 "$IMAGE" 25G
sudo qemu-nbd --connect=$NBD $IMAGE
# Bootfähig machen für BIOS/mbr
sudo parted "$NBD" set 1 boot on
sudo parted "$NBD" --script mklabel msdos mkpart primary ext4 1MiB 100%
sudo mkfs.ext4 ${NBD}p1
sudo mount ${NBD}p1 $MOUNTPOINT


# 2. Rootverzeichnis kopieren in Image
#sudo rsync -aHAX /media/backup/timeshift/snapshots/2019-12-30_22-47-22/localhost/ /mnt/rootfs/

# sudo mkdir -p /mnt/rootfs/{proc,sys,dev}

# 3. Image aushängen
# nimm dafür start.chroot.sh

# 4. Image einhängen und chroot starten
# nimm dafür start.chroot.sh


# 5. /etc/fstab anpassen
# UUID ermitteln 
# blkid | grep -i nbd

# 6. grub installieren
# echo 'GRUB_DISABLE_OS_PROBER=true' >> /etc/default/grub
# GRUB_TIMEOUT=5
# GRUB_TIMEOUT_STYLE=menu
# grub-install /dev/nbd0 --recheck --debug
# update-grub
#

# 7. ssh - Verbindung wenn möglich
# ggf. floppy-Modul dauerhaft deaktivieren
# echo "blacklist floppy" > /etc/modprobe.d/blacklist-floppy.conf
# update-initramfs -u
# Wenn grafische System nicht startet, prüfen mit: systemctl get-default 
# systemctl set-default multi-user.target -> einloggen auf konsole
# systemctl set-default graphical.target  -> grafische Login
# reboot
# auf konsole einloggen
# startx oder xinit ausführen -> Fehlermeldung beobachten


# 7. Netzwerk vorbereiten
# kopiere den Inhalt von /etc/resolv.conf 
# /etc/resolv.conf -> ../run/resolvconf/resolv.conf