Mevcut Raspbian kurulumunu daha küçük bir SD karta kopyalayın

Mevcut ve yapılandırılmış bir Raspbian kurulumunu daha küçük bir SD karta kopyalamak mümkün mü?

Raspbian'ı ilk kurduğumda elimde sadece 32 GB'lık bir kart vardı, ki bu kesinlikle gerekenden daha büyüktü.

Bu cevapta, insanların çözümün arkasındaki mantığı anlama ve diğer problemlerinde adımlar uygulayabilmeleri için adım adım ne yapılması gerektiğini gösteriyorum.

Ancak öncelikle, dosya sistemlerini bir SD karttan daha küçük (ancak veri için yeterince büyük) bir SD kartına geçirmenin genel (raspi'ye özgü olmayan) bir sorun olduğu belirtilmelidir.

Gereksinimler

Üzerinde mikro SD kart okuyucu ve Linux (Ubuntu'yu tercih ediyorum) ile çalışan bir dizüstü bilgisayar.

Kısaltmalar

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

SD_CARD_A'nın bölümleri

PIBOX çalışırken, bölümleri listeleriz (gereksiz sistem bölümleri burada gösterilmez).

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

SD_CARD_A üzerinde /ve olarak 2 bölüm var /boot. Toplamda 2GB bile kullanılmıyor.

Yedekleme SD_CARD_A

PIBOX'u kapatıp durdurduktan sonra, SD_CARD_A'yı PIBOX kartından alıp dizüstü bilgisayarımızın kart okuyucusuna yerleştirdik.

SD_CARD_A bölümleri sistemimize otomatik olarak /dev/sdc1ve olarak eklenir /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

Bu bölümleri, sistem üzerinde başarıyla çalışacak şekilde sistemimizden ayırıyoruz.

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

SD_CARD_A cihaz bilgisini sonraki adımlardaki onaylar için detaylı olarak görüntülüyoruz.

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

Yukarıda SD_CARD_A’nın 8GB kapasiteye sahip olduğunu görebilirsiniz.

SD_CARD_A'yı pibox.img dosyasına klonladık.

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

Kopyalanan baytların büyüklüğünü kontrol edin, fdisk -l /dev/sdckomut tarafından aldığımız değere eşittir .

Linux geri döngü modülü

Linux, geridöngü adı verilen ve bir dosyayı blok aygıtı olarak kullanmamızı sağlayan bir modüle sahiptir.

Geri döngü modülünü yüklüyoruz.

root@mylaptop:~# modprobe loop

Kullanılmayan bir geridöngü aygıtı yolu bulduk

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

Şimdi, pibox.img dosyası için bir geridöngü aygıtı oluşturuyoruz.

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

Bölüm değişiklikleriyle ilgili çekirdeği tetikliyoruz.

root@mylaptop:~# partprobe /dev/loop0

Önceki işlemlerin başarılı olup olmadığını onaylıyoruz.

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

SD_CARD_A ile karşılaştırmak için loopback cihaz bilgilerini detaylı olarak görüntüleriz.

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

Yukarıda geri döngü cihaz boyutunun (= 7969177600 bytes) ve bölümlerin SD_CARD_A ile aynı olduğunu görebilirsiniz.

Temel Matematik

Şu andan itibaren bölüme odaklanacağız /dev/loop0p2. Adını THE_PARTITION olarak atalım .

Blok boyutu 512 bayttır (Units ile başlayan satırlara yazdırıldığı gibi = sektörler .....)

TANITIM 137216 bloğundan başlamaktadır ve 15564799 bloğunda sona ermektedir, bunun anlamı, 15427584 blocks(= 15564799 - 137216 + 1) olmasıdır.

Dolayısıyla, THE_PARTITION öğesinin bayt olarak boyutu 7898923008 bytes(= 512 * 15427584).

SD_CARD_B içinde THE_PARTITION sığdırmak için, biz sahip olmak istiyorum yeni bir boyut 3710940 blocks veya başka bir deyişle 1900001280 bytes(= 512 * 3710940).

Böylece, yeni bitiş bloğu numarası (= 137216) + (= 3710940) - ile 3848155hesaplanır .start block numbersize in blocks1

Dosya sistemi vs. bölüm

Birbiriyle karıştırılmaması gereken 2 işlem var.

• Dosya sistemini yeniden boyutlandırma. Dosya sistemini THE_PARTITION'da boyutunu küçülterek küçülteceğiz 3710940 blocks.
• Bölümü yeniden boyutlandırma. THE_PARTITION öğesini, son blok numarasını olarak ayarlayarak küçülteceğiz 3848155.

Küçülen dosya sistemi

Dosya sistemini küçültmeden önce temiz olarak işaretlenmiş olmalıdır 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

Dosya sistemini küçültüyoruz 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.

Küçülen bölüm

THE_PARTITION numarasının ne olduğunu öğreniyoruz 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

THE_PARTITION'ı ile birlikte küçültüyoruz 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  

Geridöngü aygıtı ile işimiz bitti. Çıkarıyoruz.

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

Görüntü dosyası kesiliyor

Yeni bölüm tablosunu doğruladık.

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

Çıktıda, THE_PARTITION'ın bitiş bloğu sayısının azaldığı açıkça görülüyor from 15564799 to 3848155.

Kullandığımız son blok 3848155. 0. So blok numaralandırması başlangıç, biz toplamda 3.848.155 + 1 blokları var ve pibox.img dosyanın yeni boyutu olmalıdır 1970255872 bytes (= (3.848.155 + 1) * 512).

Pibox.img dosyasını kısalttık.

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

Pibox.img dosyasının yeni boyutunu doğruladık.

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

SD_CARD_B oluşturma

SD_CARD_B'yi dizüstü bilgisayarımızın kart okuyucusuna yerleştirdik. SD_CARD_B bölümleri sistemimize otomatik olarak /dev/sdc1ve olarak eklenir /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

Yukarıda SD_CARD_B'nin 2GB kapasiteye sahip olduğunu görebilirsiniz.

SD_CARD_B üzerinde başarılı bir şekilde çalışması için bu bölümleri sistemimizden ayırıyoruz.

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

Pibox.img dosyasını SD_CARD_B içine klonladık.

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

Kopyalanan baytların büyüklüğünü kontrol edin, ls -l pibox.imgkomut tarafından aldığımız değere eşittir .

PIBOX'un Önyüklenmesi

SD_CARD_B'yi dizüstü bilgisayarımızdan çıkardıktan ve PIBOX kartına yerleştirdikten sonra, sistemi açıp PIBOX konsoluna giriş yapıyoruz.

Bölümleri listeleriz (diğer bazı gereksiz sistem bölümleri burada gösterilmez).

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

Eğer kullanıldığında dd if=/dev/sdx of=/path/to/image bs=1M, /dev/sdxgörüntü daima bütün kartın boyutu olacağını, böylece entire "disk" anlamına gelir.

Bunun yerine, bölüm numarasının dd if=/dev/sdxn ...nerede nolduğunu kullanmanız gerekir .

Muhtemelen bunu iki kez yapmanız gerekecek - /bootbölüm için bir kez ve /bölüm için bir kez .

O zaman içeriği değiştirmek için yeni kartta en az bu iki orijinal olan kadar büyük bölümler oluşturmanız gerekir.

Birincil bölümü daha küçük bir boyuta küçültmek için bölümlü (bölüm düzenleyicisi) gibi bir şey kullanın ve ardından şimdiki küçük bölümden yeni kartınıza kopyalamak için Clonezilla gibi bir araç kullanın. Yine de, bunu başka bir bilgisayarda yapmanız gerekecek.

1. Kartın bir görüntüsünü yukarıda belirtilen yöntemlerden birini kullanarak oluşturma - Raspberry Pi'mi nasıl yedeklerim?

2. Resmi küçültmek için http://sirlagz.net/2013/03/10/script-automatic-rpi-image-downsizer/ adresindeki betiği kullanın

3. Küçültülmüş görüntüyü daha küçük bir kağıda geri yükleyin.

Kullanıyorum rsync dosya sistemlerini bir diskten diğerine kopyalamak . Rsync kullanmanın avantajı, cihazın blok düzeyinde bir kopyasını yapmak yerine dosya sisteminin içeriğini kopyalamasıdır; Sonuç olarak, hedef sürücü ve kaynak sürücülerin boyutu ne kadardır, hedef sürücü verileri tutmak için yeterli alana sahip olduğu sürece.

İşte burada nasıl yaparım:

1. İstediğiniz yeni, daha küçük SD kartına yeni bir raspbian kurulumu oluşturun.
2. Yeni yüklemeye önyükleme yapın ve tüm diski doldurmak için dosya sistemini genişletin. Pi'yi kapat.
3. Şimdi yeni ve eski kartları takın ve kullanın. rsync -avx oldFilesystem newFilesystem takın ve yeni karttaki dosya sistemini eski karttaki dosya sistemiyle kopyalamak / üzerine yazmak için .
4. Sonunda, yeni sisteminize önyükleme yapın ve rpi-updatebellenimin tutarlı ve güncel olduğundan emin olmak için çalıştırın .

Bundan sonra, yeni kartınızın üzerine kurulu mükemmel işlevsel bir Raspbian sistemi olmalıdır.

SD Karttaki tüm verileri yedeklemek ve geri yüklemek için bir kabuk betiği oluşturdum. İlk önce bazı verileri siler (projeme karşılık gelir) ve bölümü minimum boyuta kadar küçültür, böylece görüntü SD kartındaki veriler kadar büyük olur. Ek olarak, komut dosyası görüntünün * .zip dosyasını oluşturur. Oluşturulan görüntüyü başka bir SD Karta geri yükledikten sonra, bölüm maksimum boyutuna büyütülecektir. Komut diğer cevaplarda belirtilen komutları kullanır. Bu benim yumruk kabuk betiği bu boyutta olduğu için onu oluşturmak için saat sürdü ve mükemmel bir jet değil. Özellikle resize2fs ve fdisk'in dönüş değerlerini nasıl kullanacağımı bilmiyorum, böylece kullanıcı ihtiyacım olan değerleri yazmalı. Bunu düzeltecek bir fikrin var mı? Umarım bu senaryo başkasına yardımcı olur. Düzenlemek ve geliştirmek için çekinmeyin.

"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

işte burada:

#!/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

Bulduğum en kolay çözüm, yukarıda belirtilen dd komutlarını kullanarak orijinal daha büyük kartın bir yedeğini almak ve daha sonra görüntüyü piwriter gibi bir şey kullanarak daha küçük karta geri yüklemek oldu. DD çalışabilir ... emin değilim. PiWriter odasından çıktığı için bir hata döndürdü, ancak görüntü küçük kartın boyutunun ötesinde herhangi bir gerçek veri içermediğinden sadece boş kesimleri kesiyordu. Bunun ne anlama geldiğinden emin değilim ... bölümlerin denetlenmesi veya onarılması gerekebilir, ancak Pi'ye yerleştirdiğimde çalıştığını doğrulayabilirim.

win32diskimager-RELEASE-0.1-r15-win32Görüntüyü okumak için eski bir sürümünü kullanıyorum , 8GB SD karttan bile 4 GB'lık bir görüntü oluşturuyor ve sonra win32diskimager'ın en son sürümüyle görüntüyü yazıyor.

Eski sürümü kullanıyorum, çünkü eski sürüm her hatayı atlayacak.