Kopieren Sie die vorhandene Raspbian-Installation auf eine kleinere SD-Karte

25

Ist es möglich, eine vorhandene und konfigurierte Raspbian-Installation auf eine kleinere SD-Karte zu kopieren?

Als ich Raspbian zum ersten Mal installierte, hatte ich nur eine 32-GB-Karte zur Hand, die offensichtlich größer ist als nötig.

mwld
quelle
Das System läuft besser und die Karte hält länger mit mehr freiem Speicherplatz in Ihrer primären Partition. Verkleinern Sie sie also nicht zu stark - behalten Sie mindestens die doppelte Auslastung bei (z. B. wenn Ihr System 2-3 GB umfasst, verwenden Sie eine 8 GB Speicherkarte und vergrößern Sie die Partition, um den gesamten verfügbaren Speicherplatz zu füllen. Beachten Sie, dass die Partition, wenn Sie sie nicht vergrößert haben, nicht 32 GB groß ist, sodass Sie sie möglicherweise nicht verkleinern müssen.
Goldlöckchen
Vielen Dank für den Hinweis, aber meine Himbeere verwendet derzeit nur 1,8 GB, da es sich um eine wirklich einfache Installation handelt. 4 GB sollten also ausreichen.
mwld
Ich denke, ich habe es auf die volle Größe gebracht, als ich Debian Wheezy zum ersten Mal installiert habe. Jetzt habe ich es auf 2,5 GB geschrumpft, aber immer noch keinen Erfolg. Siehe meine Kommentare unten.
mwld
Nahezu doppelt: raspberrypi.stackexchange.com/q/29947/5538
Goldlöckchen
1
Wenn eine der folgenden Antworten Ihre Frage erfüllt, überprüfen Sie bitte die Antwort.
Wes Modes

Antworten:

12

In dieser Antwort zeige ich Schritt für Schritt, wie Menschen die Logik hinter der Lösung verstehen und Schritte auf ihre anderen Probleme anwenden können.

Zunächst sollte jedoch festgestellt werden, dass es ein generisches (nicht raspi-spezifisches) Problem ist, Dateisysteme von einer SD-Karte auf eine kleinere (aber für Daten ausreichend große) SD-Karte zu migrieren.

Bedarf

Ein Laptop mit einem Micro-SD-Kartenleser und Linux (ich bevorzuge Ubuntu) läuft darauf.

Abkürzungen

PIBOX      : Raspberry Pi which is used
SD_CARD_A  : 8GB micro SD card which is used on PIBOX and on which Raspbian-lite (the OS) is installed
SD_CARD_B  : 2GB micro SD card which will be used on PIBOX and on which Raspbian-lite (the OS) will be installed

Partitionen von SD_CARD_A

Während PIBOX ausgeführt wird, listen wir die Partitionen auf (unnötige Systempartitionen werden hier nicht angezeigt).

root@pibox:~# df -Th
Filesystem     Type      Size  Used Avail Use% Mounted on
/dev/root      ext4      7.3G  1.1G  5.9G  16% /
/dev/mmcblk0p1 vfat       63M   21M   43M  33% /boot

Es gibt 2 Partitionen auf SD_CARD_A als /und /boot. Sogar 2 GB werden insgesamt nicht verwendet.

Sichern Sie SD_CARD_A

Nachdem wir PIBOX heruntergefahren und angehalten haben, nehmen wir SD_CARD_A von der PIBOX-Platine und stecken es in den Kartenleser unseres Laptops.

Partitionen von SD_CARD_A werden automatisch als /dev/sdc1und in unser System eingebunden /dev/sdc2.

root@mylaptop:~# df -Th
Filesystem                    Type      Size  Used Avail Use% Mounted on
/dev/sdb2                     ext4       22G   13G  7.9G  63% /
/dev/sdb1                     vfat      197M  2.6M  195M   2% /boot/efi
/dev/sda8                     ext4       66G   11G   52G  17% /home
/dev/sdc1                     vfat       63M   21M   43M  33% /media/some_user_name/boot
/dev/sdc2                     ext4      7.3G  1.1G  5.9G  16% /media/some_user_name/some_uuid_serial

Wir heben diese Partitionen von unserem System ab, um sie erfolgreich zu bearbeiten.

root@mylaptop:~# umount /dev/sdc1
root@mylaptop:~# umount /dev/sdc2

Wir zeigen die Geräteinformationen von SD_CARD_A in Details zur Bestätigung in den nächsten Schritten an.

root@mylaptop:~# fdisk -l /dev/sdc
Disk /dev/sdc: 7969 MB, 7969177600 bytes
246 heads, 62 sectors/track, 1020 cylinders, total 15564800 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x2019f6d8

   Device Boot      Start         End      Blocks   Id  System
/dev/sdc1            8192      137215       64512    c  W95 FAT32 (LBA)
/dev/sdc2          137216    15564799     7713792   83  Linux

Oben sehen Sie, dass SD_CARD_A eine Kapazität von 8 GB hat.

Wir klonen SD_CARD_A in die Datei pibox.img.

root@mylaptop:~# dd bs=4MB if=/dev/sdc of=pibox.img
1992+1 records in
1992+1 records out
7969177600 bytes (8.0 GB) copied, 416.582 s, 19.1 MB/s

Überprüfen Sie die Größe der kopierten Bytes. Sie entspricht dem Wert, den wir per fdisk -l /dev/sdcBefehl erhalten haben.

Linux Loopback-Modul

Linux hat ein Modul namens Loopback, das es uns ermöglicht, eine Datei als Blockgerät zu behandeln.

Wir laden das Loopback-Modul.

root@mylaptop:~# modprobe loop

Wir finden einen nicht verwendeten Loopback-Gerätepfad.

root@mylaptop:~# losetup -f /dev/loop0

Jetzt erstellen wir ein Loopback-Gerät für die Datei pibox.img.

root@mylaptop:~# losetup /dev/loop0 pibox.img

Wir lösen einen Kernel über Partitionsänderungen aus.

root@mylaptop:~# partprobe /dev/loop0

Wir bestätigen, ob die vorherigen Operationen erfolgreich waren.

root@mylaptop:~# losetup /dev/loop0
/dev/loop0: [0806]:69 (/root/pibox.img)

Wir zeigen die Loopback-Geräteinformationen im Detail an, um sie mit SD_CARD_A zu vergleichen.

root@mylaptop:~# fdisk -l /dev/loop0
Disk /dev/loop0: 7969 MB, 7969177600 bytes
255 heads, 63 sectors/track, 968 cylinders, total 15564800 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x2019f6d8

      Device Boot      Start         End      Blocks   Id  System
/dev/loop0p1            8192      137215       64512    c  W95 FAT32 (LBA)
/dev/loop0p2          137216    15564799     7713792   83  Linux

Oben sehen Sie, dass die Größe des Loopback-Geräts (= 7969177600 Byte) und die Partitionen mit denen von SD_CARD_A identisch sind.

Grundlegende Mathematik

Ab sofort konzentrieren wir uns auf die Partition /dev/loop0p2. Nennen wir es THE_PARTITION .

Die Blockgröße beträgt 512 Bytes (wie auf der Zeile gedruckt, die mit Einheiten = Sektoren beginnt .....)

THE_PARTITION beginnt bei Block 137216 und endet bei Block 15564799, was bedeutet, dass es die Größe von 15427584 blocks(= 15564799 - 137216 + 1) hat.

Die Größe von THE_PARTITION in Bytes ist also 7898923008 bytes(= 512 * 15427584).

Damit THE_PARTITION in SD_CARD_B passt, soll es eine neue Größe von 3710940 blocks oder mit anderen Worten 1900001280 bytes(= 512 * 3710940) haben.

Die neue Endblocknummer wird also 3848155mit start block number(= 137216) + size in blocks(= 3710940) - berechnet 1.

Dateisystem vs. Partition

Es gibt 2 Operationen, die nicht für einander verwechselt werden sollten.

  • Größe des Dateisystems ändern. Wir werden das Dateisystem auf THE_PARTITION verkleinern, indem wir seine Größe auf setzen 3710940 blocks.
  • Partitionsgröße ändern. Wir werden THE_PARTITION verkleinern, indem wir seine Endblocknummer auf setzen 3848155.

Verkleinertes Dateisystem

Bevor Sie das Dateisystem verkleinern, sollten Sie es als sauber markieren e2fsck.

root@mylaptop:~# e2fsck -f /dev/loop0p2
e2fsck 1.42.9 (4-Feb-2014)
Pass 1: Checking inodes, blocks, and sizes
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
Pass 4: Checking reference counts
Pass 5: Checking group summary information
/dev/loop0p2: 41175/475776 files (0.2% non-contiguous), 309183/1928448 blocks

Wir verkleinern das Dateisystem mit resize2fs.

root@mylaptop:~# resize2fs /dev/loop0p2 3710940s
resize2fs 1.42.9 (4-Feb-2014)
Resizing the filesystem on /dev/loop0p2 to 463867 (4k) blocks.
The filesystem on /dev/loop0p2 is now 463867 blocks long.

Schrumpfende Partition

Wir erfahren, mit welcher THE_PARTITION-Nummer parted.

root@mylaptop:~# parted /dev/loop0
GNU Parted 2.3
Using /dev/loop0
Welcome to GNU Parted! Type 'help' to view a list of commands.
(parted) print                                                            
Model: Loopback device (loop)
Disk /dev/loop0: 7969MB
Sector size (logical/physical): 512B/512B
Partition Table: msdos

Number  Start   End     Size    Type     File system  Flags
 1      4194kB  70.3MB  66.1MB  primary  fat16        lba
 2      70.3MB  7969MB  7899MB  primary  ext4

(parted) quit

Wir verkleinern THE_PARTITION mit parted.

root@mylaptop:~# parted /dev/loop0 unit s resizepart 2 3848155
Warning: Shrinking a partition can cause data loss, are you sure you want to continue?
Yes/No? Yes  

Wir sind mit dem Loopback-Gerät fertig. Wir lösen es.

root@mylaptop:~# losetup -d /dev/loop0

Bilddatei wird abgeschnitten

Wir überprüfen die neue Partitionstabelle.

root@mylaptop:~# fdisk -l pibox.img 

Disk pibox.img: 7969 MB, 7969177600 bytes
255 heads, 63 sectors/track, 968 cylinders, total 15564800 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x2019f6d8

    Device Boot      Start         End      Blocks   Id  System
pibox.img1            8192      137215       64512    c  W95 FAT32 (LBA)
pibox.img2          137216     3848155     1855470   83  Linux

In der Ausgabe ist deutlich zu sehen, dass die Endblocknummer von THE_PARTITION verringert wird from 15564799 to 3848155.

Der letzte Block, den wir verwenden, ist 3848155. Die Blocknummerierung beginnt bei 0. Wir haben also insgesamt 3848155 + 1 Blöcke und die neue Größe der Datei pibox.img sollte 1970255872 bytes (= (3848155 + 1) * 512) sein.

Wir kürzen die Datei pibox.img.

root@mylaptop:~# truncate --size=1970255872 pibox.img

Wir überprüfen die neue Größe der Datei pibox.img.

root@mylaptop:~# ls -l pibox.img 
-rw-r--r-- 1 root root 1970255872 Oct 13 21:53 pibox.img

SD_CARD_B erstellen

Wir stecken SD_CARD_B in den Kartenleser unseres Laptops. Partitionen von SD_CARD_B werden automatisch als /dev/sdc1und in unser System eingebunden /dev/sdc2.

root@mylaptop:~# df -Th
Filesystem                    Type      Size  Used Avail Use% Mounted on
/dev/sdb2                     ext4       22G   13G  7.9G  63% /
/dev/sdb1                     vfat      197M  2.6M  195M   2% /boot/efi
/dev/sda8                     ext4       66G   11G   52G  17% /home
/dev/sdc1                     vfat       63M   21M   43M  33% /media/some_user_name/boot
/dev/sdc2                     ext4      1.8G  1.6G   59M  97% /media/some_user_name/some_uuid_serial

Oben sehen Sie, dass SD_CARD_B eine Kapazität von 2 GB hat.

Wir heben diese Partitionen von unserem System ab, um SD_CARD_B erfolgreich zu verarbeiten.

root@mylaptop:~# umount /dev/sdc1
root@mylaptop:~# umount /dev/sdc2

Wir klonen die Datei pibox.img in SD_CARD_B.

root@mylaptop:~# dd bs=4MB if=pibox.img of=/dev/sdc
492+1 records in
492+1 records out
1970255872 bytes (2.0 GB) copied, 646.967 s, 3.0 MB/s

Überprüfen Sie die Größe der kopierten Bytes. Sie entspricht dem Wert, den wir per ls -l pibox.imgBefehl erhalten haben.

PIBOX booten

Nachdem wir SD_CARD_B von unserem Laptop genommen und in die PIBOX-Karte gesteckt haben, booten wir das System und melden uns bei der PIBOX-Konsole an.

Wir listen die Partitionen auf (einige andere unnötige Systempartitionen werden hier nicht angezeigt).

root@pibox:~# df -Th
Filesystem     Type      Size  Used Avail Use% Mounted on
/dev/root      ext4      1.8G  1.1G  601M  64% /
/dev/mmcblk0p1 vfat       63M   21M   43M  33% /boot
vaha
quelle
Gut Ich denke, einige Ihrer Aufgaben beim Einrichten des Loopbacks sind möglicherweise langwierig und unnötig. Vielleicht möchten Sie das überprüfen. Etwas sehr Ähnliches aus einer sehr ähnlichen Frage: raspberrypi.stackexchange.com/a/29952/5538
Goldlöckchen
@goldilocks, nicht getestet, aber ich denke, Loopback ist notwendig. Soweit ich weiß, dass Parted nicht direkt mit Bilddateien arbeiten kann, benötigt es eine Geräteschnittstelle für seine Operationen.
Vaha
Ja , aber ich glaube , Sie Sie nicht finden müssen stören losetupoder sogar -o loop=whatever. Wie in dem anderen Beitrag, den ich gerade benutze, ist mount -o offset=123 /imagefilepath /mntpointdie Verwendung von Loopback implizit. Ich nehme an, dass das jetzt unter Linux im Allgemeinen zutrifft - probieren Sie es aus. Sie können dies dann auf die Angabe reduzieren, dass die Partitionen über ein virtuelles "Loopback-Gerät" gemountet werden.
Goldlöckchen
5

Wenn Sie verwendet haben dd if=/dev/sdx of=/path/to/image bs=1M, /dev/sdxbezieht sich dies auf die gesamte "Festplatte", sodass das Image immer die Größe der gesamten Karte hat.

Stattdessen müssten Sie verwenden, dd if=/dev/sdxn ...wo ndie Partitionsnummer ist.

Sie müssen dies wahrscheinlich zweimal tun - einmal für die /bootPartition und einmal für die /Partition.

Dann müssten Sie Partitionen auf der neuen Karte erstellen, die mindestens so groß sind wie die beiden ursprünglichen, um den Inhalt wieder in den ursprünglichen Zustand zu versetzen.

John La Rooy
quelle
3

Verwenden Sie so etwas wie parted (Partitionseditor), um die primäre Partition auf eine kleinere Größe zu verkleinern, und verwenden Sie dann ein Tool wie Clonezilla, um von der jetzt kleineren Partition auf Ihre neue Karte zu kopieren. Sie müssen dies jedoch wahrscheinlich auf einem anderen Computer tun.

Jerry Gagnon
quelle
Das hat leider nicht geklappt. Ich habe die Partition mit GParted auf 2,5 GB verkleinert. Aber als ich versuchte, ein Image von ihm auf einen USB-Stick zu erstellen, wurde es viel größer (4,3 GB - aber ich denke, es wollte die gesamten 32 GB kopieren und hielt nur bei 4,3 GB an, weil die Dateigröße auf FAT begrenzt war).
mwld
2
Ich habe den Befehl dd if=/dev/sdx of=/path/to/image bs=1Maus diesem Thread verwendet: raspberrypi.stackexchange.com/questions/311/…
mwld
Haben Sie Ideen, wie ich die primäre Partition mit 2,5 GB in ein Image kopieren und trotzdem eine SD-Karte mit bootfähigem Raspbian daraus erstellen kann?
mwld
Entschuldigung für die späte Antwort. Ich habe mit einer 4-GB-SD-Karte begonnen, ein Image erstellt und dieses Image dann auf 8-GB-Karten und größere Karten geschrieben. Ich brauchte noch keine größere Partition für alles, woran ich gearbeitet habe. Ich kenne kein Tool, mit dem Sie einfach ein Image einer einzelnen Partition auf einer SD-Karte erstellen können.
Jerry Gagnon
3
  1. Erstellen Sie ein Image der Karte mit einer der bereits erwähnten Methoden - Wie sichere ich meinen Raspberry Pi?

  2. Verwenden Sie das Skript unter http://sirlagz.net/2013/03/10/script-automatic-rpi-image-downsizer/, um das Bild zu verkleinern

  3. Stellen Sie das verkleinerte Bild auf einer neuen kleineren Karte wieder her

Mihir
quelle
Ich bin auf diese Seite gestoßen, als ich versuche, dasselbe Ziel zu erreichen, um ein Backup meines Raspbian-Images zu haben, aber ich möchte nicht, dass die ganze Karte NUR relevante Daten auf der Karte enthält. Gemäß dem obigen Vorschlag habe ich hier nach einem Skript gesucht. Sirlagz.net/2013/03/10/script-automatic-rpi-image-downsizer , konnte aber kein Skript finden. Kann jemand diesen Link aktualisieren, wenn er irgendwo verfügbar ist?
Shallyverma
Ich kann immer noch auf den Link zugreifen und der Post selbst ist ein Skript. Kopieren Sie das Skript in eine Datei und benennen Sie es script.sh. Machen Sie die Datei mit ausführbar chmodund führen Sie sie aus.
Mihir
1

Seit einiger Zeit rsynckopiere ich Dateisysteme ohne Probleme von einer Festplatte auf eine andere. Der Vorteil von rsync besteht darin, dass der Inhalt des Dateisystems kopiert wird, anstatt eine Kopie des Geräts auf Blockebene zu erstellen. Daher ist es wirklich egal, wie groß die Ziel- und Quelllaufwerke sind, solange das Ziellaufwerk über genügend Speicherplatz für die Daten verfügt.

So würde ich es machen:

  1. Erstellen Sie eine neue Raspbian-Installation auf Ihrer gewünschten neuen, kleineren SD-Karte.
  2. Starten Sie die neue Installation und erweitern Sie das Dateisystem, um die gesamte Festplatte zu füllen. Fahren Sie den Pi herunter.
  3. Montieren Sie nun die neue und die alte Karte und rsync -avx oldFilesystem newFilesystemkopieren / überschreiben Sie das Dateisystem auf der neuen Karte mit dem Dateisystem von der alten Karte.
  4. Starten Sie schließlich Ihr neues System und führen Sie es aus rpi-update, um sicherzustellen, dass Ihre Firmware konsistent und auf dem neuesten Stand ist.

Danach sollte auf Ihrer neuen Karte ein einwandfrei funktionierendes Raspbian-System installiert sein.

sdenton4
quelle
Also brauche ich für diese Methode (Schritt 3) 2 SD-Kartenleser?
Victor Van Hee
Entweder zwei SD-Kartenleser oder ein Zwischengerät. Sie können das alte Dateisystem mit einem Ordner auf Ihrer Festplatte synchronisieren und diesen Ordner dann mit der zweiten SD-Karte synchronisieren, wenn Sie keinen Reader mitnehmen möchten.
sdenton4
1

Ich habe ein Shell-Skript erstellt, um alle Daten auf einer SD-Karte zu sichern und wiederherzustellen. Es löscht zuerst einige Daten (die meinem Projekt entsprechen) und verkleinert die Partition auf die Mindestgröße, damit das Image so groß ist wie die Daten auf der SD-Karte. Zusätzlich erstellt das Skript eine * .zip-Datei des Bildes. Nach dem Wiederherstellen des erstellten Images auf einer anderen SD-Karte wird die Partition auf die maximale Größe vergrößert. Das Skript verwendet die Befehle, die in den anderen Antworten erwähnt werden. Da dies mein erstes Shell-Skript mit dieser Größe ist, habe ich Stunden gebraucht, um es zu erstellen, und es ist kein perfekter Jet. Insbesondere weiß ich nicht, wie ich mit den Rückgabewerten von resize2fs und fdisk umgehen soll, sodass der Benutzer die von mir benötigten Werte eingeben muss. Gibt es irgendwelche Ideen, um das zu beheben? Ich hoffe, dieses Skript hilft jemand anderem. Fühlen Sie sich frei, es zu bearbeiten und zu verbessern.

"Usage:
    <skriptname> -b <path>                  create backup of SC Card (dev/mmcblk0) to file <path>/JJJJ-MM-DD_HHMM.img
    <skriptname> -r <path>/FILENAME.img     restore an exitsting image (<path>/FILENAME.img) to the SD Card (dev/mmcblk0) 
    <skriptname> -r <path>/FILENAME.zip     unzip and restore an exitsting image (<path>/FILENAME.zip) to the SD Card (dev/mmcblk0)
    <skriptname> -h                         show this hlep

hier ist es:

#!/bin/bash 

# check if the user is root
if (( $EUID != 0 )); then
  echo "This script requires root privileges please run as root"
  exit
fi


while getopts ":b:r:h" opt; do
  case $opt in
    b)
      mode="backup"
      OUTPATH=$OPTARG
      ;;
    r)
      mode="restore"
      DIRFILENAME=$OPTARG
      ;;
    h)
      mode="help"
      ;;
    \?)
      echo "Invalid option: -$OPTARG. Use -h for help" >&2
      exit 1
      ;;
    :)
      echo "Option -$OPTARG requires an argument. Use -h for help" >&2
      exit 1
      ;;
  esac
done
# no option
if [ $OPTIND == 1 ]
then
  echo "$(basename "$0") needs an option! Use -h for help"
  exit 1
fi


myMount(){
  # create mountpoint if not existing
  if [ ! -d /tmp/sd2/ ] ; then
    mkdir /tmp/sd2
  fi

  # mount partition
  mount -v -t ext4 /dev/mmcblk0p2 /tmp/sd2
  err=$?
  if [ $err != 0 ]; then
    echo "mount failed error: $err"
    exit 1
  fi
}

myUmount(){
  cd /home/ # otherwise umount will fail
  # fuser -vm /tmp/sd2/

  # umount partition
  umount -v /tmp/sd2
  err=$?
  if [ $err != 0 ]; then
    echo "umount failed error: $err"
    exit 1
  fi
}

myEnlarge(){
  echo "enlarge partition..."
  # enlarge partition is not posible with fdisk -> delete and recreate it
  (
  echo d # delete partition
  echo 2 # patition number
  echo n # add a new partition
  echo p # primary partition
  echo 2 # partition number
  echo   # first sector (accept default: varies)
  echo   # last sector (accept default: varies)
  echo w # write changes
  ) | fdisk /dev/mmcblk0

  echo "\n check filesystem... "
  e2fsck -f -v -C 0 /dev/mmcblk0p2

  # enlarge filesystem to maxsize
  resize2fs -p /dev/mmcblk0p2
}

case "$mode" in
"help")
  echo "Usage:
    $(basename "$0") -b <path>                  create backup of SC Card (dev/mmcblk0) to file <path>/JJJJ-MM-DD_HHMM.img
    $(basename "$0") -r <path>/FILENAME.img     restore an exitsting image (<path>/FILENAME.img) to the SD Card (dev/mmcblk0) 
    $(basename "$0") -r <path>/FILENAME.zip     unzip and restore an exitsting image (<path>/FILENAME.zip) to the SD Card (dev/mmcblk0)
    $(basename "$0") -h                         show this hlep
--------------------------------
Adrian Zeitler, Germany 2017"
  ;;
"backup")  ####################################### backup ####################################### 
  echo "an image of the SD Card (/dev/mmcblk0) whitch is as smal as possible will be created to $OUTPATH."
  # ------------------  delete some data --------------------

  echo "Do you want to delete tempfiles? [y/n]" 
  read delfiles

  if [ "$delfiles" = "y" ]
    then
      echo "Delete tempfiles..."

      myMount

      # remove some data
      cd /tmp/sd2/home/alarm/
      rm -v -f hagelbeere.db
      rm -v -f HAILcam.log
      rm -v -f HAILcam.log.1
      rm -v -f test.jpg

      myUmount

    elif [ "$delfiles" = "n" ]
      then
    echo "I don't delete anything."
    else
    echo "Sorry, I didn't understand."
    exit 1
  fi


  # --------------------------------------------------------------
  # shrink partition 2 to minimum size

  echo "check file system... "
  e2fsck -f -v -C 0 /dev/mmcblk0p2
  err=$?
  if [ $err != 0 ]; then
    echo "file system check failed, error: $err"
    exit 1
  fi

  echo "shrink filesystem of partition 2 to minimum size..."
  resize2fs -p -M /dev/mmcblk0p2
  err=$?
  if [ $err != 0 ]; then
    echo "resize2fs failed, error: $err"
    exit 1
  fi
  # --> Das Dateisystem auf /dev/mmcblk0p2 ist nun 692365 Blöcke groß.

  echo "Please tell me the new filesystem size displayed above:"
  read size
  # from resize2fs blocksize, fdisk wants sector: sector = block * 8
  size=$(( $size*8 ))

  # shrink partition is not posible with fdisk -> delete and recreate it
  (
  echo d # delete partition
  echo 2 # patition number
  echo n # add a new partition
  echo p # primary partition
  echo 2 # partition number
  echo   # first sector (accept default: varies)
  echo +$size  # last sector
  echo w # write changes
  ) | fdisk /dev/mmcblk0
  err=$?
  if [ $err != 0 ]; then
    echo "fdisk failed, error: $err"
    exit 1
  fi


  # --------------------------------------------------------------

  # fill unused space with zeros
  echo "Do you want to fill unused space with zeros? [y/n]" 
  read fillzeros


  if [ "$fillzeros" = "y" ]
    then
      echo "Copy zeros. This will end up with an error. But this is ok."

      myMount    

      dd if=/dev/zero | pv | dd of=/tmp/sd2/nullen.datei conv=noerror,notrunc,sync bs=10240
      # exits with error -> this is normal

      # dlelete zeros
      rm -v -f /tmp/sd2/nullen.datei
      sync

      myUmount

    elif [ "$fillzeros" = "n" ]
      then
    echo "I don't delete anything."
    else
    echo "Sorry, I didn't understand."
    exit 1
  fi

  # --------------------------------------------------------------

  # find out end of partition
  fdisk -l /dev/mmcblk0
  echo "Please tell me the end of mmcblk0p2 displayed above."
  read count



  DATE=$(date +"%Y-%m-%d_%H%M")
  IMGFILENAME=$DATE.img 
  echo "Do you want to create image with filename $OUTPATH$IMGFILENAME? [y/n]"
  read answer
  if [ "$answer" = "y" ]
  then
    echo "Do you want to create a *.zip file of the created image? [y/n]"
    read zip
    echo "Do you want to enlarge partition 2 to maxsize after image creation? [y/n]"
    read enlarge

    echo "create image..."
    cd $OUTPATH
    # create image with dd, stop at and of partition
    # count=N   copy only N input blocks
    # bs=BYTES  read and write up to BYTES bytes at a time = block size
    # pv    show status
    dd if=/dev/mmcblk0 | pv -s $(( $count*512 )) | dd of=$IMGFILENAME bs=512 count=$count
    err=$?
    if [ $err != 0 ]; then
      echo "dd failed error: $err"
      exit 1
    fi

    # --------------------------------------------------------------
    # create zip file
    # or like this:
    # sudo dd if=/dev/sdX | pv |gzip > /pfad/zur/datei.img.gz
    if [ "$zip" = "y" ]
    then
      echo "create zip file..."
      zip $DATE.zip $IMGFILENAME
    fi
    # --------------------------------------------------------------
  fi

  # --------------------------------------------------------------
  # enlarge partition 2

  if [ "$enlarge" = "y" ]
  then
    myEnlarge
  fi

  ;; #end case mode backup
"restore")  ####################################### restore ####################################### 
  #chek if image exists
  if [[ -s "$DIRFILENAME" ]]
  then
    # check if file is an image or zip file
    if [[ $DIRFILENAME =~ \.img$ ]]
    then
      IMGFILENAME=$(basename "$DIRFILENAME")
    elif [[ $DIRFILENAME =~ \.zip$ ]]
    then
      ZIPFILENAME=$(basename "$DIRFILENAME")
    else
      echo "Not the right file format. I accept *.img and *.zip"
      exit 1
    fi
  else
    echo "Image file does not exist."
    exit 1
  fi
  echo "the file $DIRFILENAME will be restored to the SD Card /dev/mmcblk0"

  #change to the path of the imagefile
  SOURCEPATH=$(dirname "$DIRFILENAME")
  cd $SOURCEPATH


  if [ "$ZIPFILENAME" != "" ]
  then
    echo "unzip file"
    # change file extention form zip zu img
    l=$(( ${#ZIPFILENAME}-3 ))
    IMGFILENAME="${ZIPFILENAME:0:l}img"
    unzip $ZIPFILENAME
  fi

  echo "Do you realy want to restore $SOURCEPATH/$IMGFILENAME to the SD card /dev/mmcblk0? 
  Warning: all data on the device /dev/mmcblk0 will be lost! [y/n]"
  read answer
  if [ "$answer" = "y" ]
  then
    echo "Do you want to enlarge partition 2 to maxsize after restoring? [y/n]"
    read enlarge
    echo "restore image..."
    filesize=$(wc -c <"$IMGFILENAME")
    echo "Filesize = $filesize Byte"
    dd if=$IMGFILENAME | pv -s $filesize | dd of=/dev/mmcblk0 bs=512
    err=$?
    if [ $err != 0 ]; then
      echo "dd failed error: $err"
      exit 1
    fi
  fi

  # --------------------------------------------------------------
  # enlarge partition 2
  if [ "$enlarge" = "y" ]
  then
    myEnlarge
  fi

  ;; #end case mode restore
esac
Adrian
quelle
0

Die einfachste Lösung, die ich gefunden habe, war, eine Sicherungskopie der ursprünglichen größeren Karte mit den oben beschriebenen Befehlen dd zu erstellen und dann das Image mit etwas wie Piwriter auf der kleineren Karte wiederherzustellen. dd kann auch funktionieren ... nicht sicher. PiWriter hat einen Fehler zurückgegeben, da kein Platz mehr vorhanden war. Da das Image jedoch keine tatsächlichen Daten über die Größe der kleineren Karte hinaus enthielt, wurden lediglich leere Sektoren abgeschnitten. Ich bin mir nicht sicher, welche Auswirkungen dies hat ... Die Partition muss möglicherweise überprüft oder repariert werden, aber ich kann überprüfen, ob sie funktioniert hat, wenn ich sie in den Pi stecke.

Hündchen
quelle
1
Dies ist ein sehr gefährlicher Rat. Sie werden nie erfahren, ob tatsächlich Daten über die Größe hinaus vorhanden waren. Wir suchen nach zuverlässigeren und bewährten Lösungen.
Lenik
Ich lebe gefährlich, was soll ich sagen;) Ganz im Ernst, obwohl ich nicht viel Erfahrung mit DD- oder Partitionskarten habe, bin ich hier auf Neuland. Ich hatte wahrscheinlich Glück, da ich nur etwa 800 MB Daten hatte, die von einer 16-GB-Karte auf eine 8-GB-Karte übertragen wurden. Gibt es jedoch aus Neugier eine Möglichkeit, die Daten zuerst zu defragmentieren, um sicherzustellen, dass sie zu Beginn der Partition gruppiert sind? Scheint aber vielleicht hackisch?
Hündchen
Ich weiß nichts über Defragmentierung, aber Sie können die Größe Ihrer Partitionen auf jeden Fall ändern und sie an den Anfang der SD-Karte verschieben, sodass sie nur den Anfang belegen. dauert etwas länger als simple dd, aber die ergebnisse sind viel zuverlässiger.
Lenik
0

Ich benutze eine alte Version von win32diskimager-RELEASE-0.1-r15-win32, um das Image zu lesen. Es erstellt sogar von einer 8 GB SD-Karte ein Image von 4 GB und schreibt dann das Image mit der neuesten Version von win32diskimager.

Ich benutze die ältere Version, weil die alte jeden Fehler überspringt.

Double-G
quelle
Gibt es nicht eine Option in der neuen Version 0.95, mit der Sie dasselbe tun können, dh jeden Fehler überspringen? Leider wird auf der SourceForge-Seite keine der verfügbaren Optionen aufgelistet. Es scheint nur leicht riskant mit Pre-Beta-Software
Greenonline
Ich bekomme keine Warm-and-Fuzzies, wenn ich ein Programm benutze, das jeden Fehler überspringt.
RufusVS