Salin instalasi Raspbian yang ada ke kartu SD yang lebih kecil

Apakah mungkin menyalin instalasi Raspbian yang sudah ada dan terkonfigurasi ke kartu SD yang lebih kecil?

Ketika saya pertama kali menginstal Raspbian, saya hanya punya kartu 32 GB yang jelas lebih besar dari yang dibutuhkan.

Dalam jawaban ini, saya menunjukkan apa yang harus dilakukan selangkah demi selangkah bagi orang untuk memahami logika di balik solusi dan untuk dapat menerapkan langkah-langkah dalam masalah mereka yang lain.

Tetapi pertama-tama, harus dinyatakan bahwa ini adalah masalah generik (tidak spesifik raspi) untuk memigrasi sistem file dari kartu SD ke kartu SD yang lebih kecil (tapi cukup besar untuk data).

Persyaratan

Laptop dengan pembaca kartu micro SD dan Linux (saya lebih suka Ubuntu) berjalan di atasnya.

Singkatan

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

Partisi SD_CARD_A

Ketika PIBOX sedang berjalan, kami mencantumkan partisi (partisi sistem yang tidak perlu tidak ditampilkan di sini).

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

Ada 2 partisi di SD_CARD_A sebagai /dan /boot. Bahkan 2GB tidak digunakan secara total.

Cadangkan SD_CARD_A

Setelah kami mematikan dan menghentikan PIBOX, kami mengeluarkan SD_CARD_A dari papan PIBOX dan memasukkannya ke pembaca kartu laptop kami.

Partisi SD_CARD_A secara otomatis dipasang ke sistem kami sebagai /dev/sdc1dan /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

Kami unmount partisi tersebut dari sistem kami agar dapat beroperasi dengan sukses.

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

Kami menampilkan info perangkat SD_CARD_A secara detail untuk konfirmasi di langkah selanjutnya.

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

Di atas Anda dapat melihat bahwa SD_CARD_A memiliki kapasitas 8GB.

Kami mengkloning SD_CARD_A ke file 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

Periksa ukuran byte yang disalin, itu sama dengan nilai yang kami dapatkan dengan fdisk -l /dev/sdcperintah.

Modul loopback Linux

Linux memiliki modul yang disebut loopback yang menyediakan kita untuk menangani file sebagai perangkat blok.

Kami memuat modul loopback.

root@mylaptop:~# modprobe loop

Kami menemukan jalur perangkat loopback yang tidak digunakan.

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

Sekarang, kami membuat perangkat loopback untuk file pibox.img.

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

Kami memicu kernel tentang perubahan partisi.

root@mylaptop:~# partprobe /dev/loop0

Kami mengkonfirmasi jika operasi sebelumnya berhasil.

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

Kami menampilkan info perangkat loopback secara detail untuk membandingkannya dengan SD_CARD_A.

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

Di atas Anda dapat melihat bahwa ukuran perangkat loopback (= 7969177600 bytes) dan partisi sama dengan SD_CARD_A.

Matematika Dasar

Mulai sekarang, kita akan fokus pada partisi /dev/loop0p2. Sebut saja THE_PARTITION .

Ukuran blok adalah 512 byte (seperti yang dicetak pada baris dimulai dengan Unit = sektor .....)

THE_PARTITION dimulai dari blok 137216 dan berakhir di blok 15564799 yang berarti memiliki ukuran 15427584 blocks(= 15564799 - 137216 +1).

Jadi, ukuran THE_PARTITION dalam byte adalah 7898923008 bytes(= 512 * 15427584).

Agar sesuai dengan THE_PARTITION dalam SD_CARD_B, kami ingin ukurannya baru 3710940 blocks atau dengan kata lain 1900001280 bytes(= 512 * 3710940).

Jadi, nomor blok akhir baru 3848155dihitung dengan start block number(= 137216) + size in blocks(= 3710940) - 1.

Filesystem vs. Partition

Ada 2 operasi yang tidak boleh keliru satu sama lain.

• Mengubah ukuran sistem file. Kami akan mengecilkan sistem file pada THE_PARTITION dengan mengatur ukurannya ke 3710940 blocks.
• Mengubah ukuran partisi. Kami akan mengecilkan THE_PARTITION dengan mengatur nomor blok akhirnya 3848155.

Menyusut sistem file

Sebelum menyusut sistem file, itu harus ditandai sebagai bersih oleh 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

Kami menyusutkan sistem file dengan 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.

Partisi menyusut

Kami mengetahui nomor THE_PARTITION itu 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

Kami menyusutkan THE_PARTITION dengan 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  

Kami selesai dengan perangkat loopback. Kami lepaskan itu.

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

Memotong file gambar

Kami memverifikasi tabel partisi baru.

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

Dalam output, terlihat jelas bahwa jumlah blok akhir THE_PARTITION berkurang from 15564799 to 3848155.

Blok terakhir yang kami gunakan adalah 3848155. Penomoran blok dimulai dari 0. Jadi, kami memiliki 3848155 +1 blok total dan ukuran baru file pibox.img seharusnya 1970255872 bytes (= (3848155 + 1) * 512).

Kami memotong file pibox.img.

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

Kami memverifikasi ukuran baru file pibox.img.

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

Membuat SD_CARD_B

Kami memasukkan SD_CARD_B ke pembaca kartu laptop kami. Partisi SD_CARD_B secara otomatis dipasang ke sistem kami sebagai /dev/sdc1dan /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

Di atas Anda dapat melihat bahwa SD_CARD_B memiliki kapasitas 2GB.

Kami melepas partisi tersebut dari sistem kami agar dapat beroperasi di SD_CARD_B dengan sukses.

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

Kami mengkloning pibox.img file ke 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

Periksa ukuran byte yang disalin, itu sama dengan nilai yang kami dapatkan dengan ls -l pibox.imgperintah.

Booting PIBOX

Setelah kami mengeluarkan SD_CARD_B dari laptop kami dan memasukkannya ke papan PIBOX, kami mem-boot sistem dan masuk ke konsol PIBOX.

Kami mencantumkan partisi (beberapa partisi sistem lain yang tidak perlu tidak ditampilkan di sini).

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

Saat Anda menggunakan dd if=/dev/sdx of=/path/to/image bs=1M, /dev/sdxmerujuk ke seluruh "disk", sehingga gambar akan selalu menjadi ukuran seluruh kartu.

Sebagai gantinya, Anda harus menggunakan di dd if=/dev/sdxn ...mana nnomor partisi.

Anda mungkin perlu melakukan ini dua kali - satu kali untuk /bootpartisi dan satu kali untuk /partisi.

Maka Anda harus membuat partisi pada kartu baru yang setidaknya sebesar dua yang asli, untuk menemukan kembali konten.

Gunakan sesuatu seperti parted (editor partisi) untuk mengecilkan partisi utama ke ukuran yang lebih kecil dan kemudian menggunakan alat seperti Clonezilla untuk menyalin dari partisi yang sekarang lebih kecil ke kartu baru Anda. Anda mungkin harus melakukan ini di komputer lain.

1. Buat gambar kartu menggunakan salah satu metode yang telah disebutkan - Bagaimana cara mencadangkan Raspberry Pi saya?

2. Gunakan skrip di http://sirlagz.net/2013/03/10/script-automatic-rpi-image-downsizer/ untuk memperkecil ukuran gambar

3. Kembalikan gambar yang dirampingkan pada kartu yang lebih kecil

Saya telah menggunakan rsyncuntuk menyalin sistem file dari satu disk ke disk lain untuk sementara waktu sekarang, tanpa cegukan. Keuntungan menggunakan rsync adalah menyalin konten sistem file, daripada melakukan salinan level-blok perangkat; sebagai hasilnya, itu benar-benar tidak peduli berapa ukuran drive target dan sumber, asalkan drive target memiliki cukup ruang untuk menyimpan data.

Jadi, inilah cara saya akan melakukannya:

1. Buat instalasi raspbian baru di kartu SD Anda yang baru dan lebih kecil yang Anda inginkan.
2. Boot ke instalasi baru dan perluas sistem file untuk mengisi seluruh disk. Matikan pi.
3. Sekarang pasang kartu baru dan lama dan gunakan rsync -avx oldFilesystem newFilesystemuntuk menyalin / menimpa sistem file pada kartu baru dengan sistem file dari kartu lama.
4. Terakhir, boot ke sistem baru Anda, dan jalankan rpi-updateuntuk memastikan bahwa firmware Anda konsisten dan terbaru.

Setelah ini, kartu baru Anda harus memiliki sistem Raspbian yang berfungsi sempurna.

Saya membuat skrip shell untuk membuat cadangan dan memulihkan semua data pada Kartu SD. Pertama menghapus beberapa data (sesuai dengan proyek saya) dan menyusutkan partisi ke ukuran minimum sehingga gambar sebesar data pada kartu SD. Sebagai tambahan, skrip membuat file * .zip dari gambar. Setelah mengembalikan gambar yang dibuat ke Kartu SD lain, partisi akan diperbesar ke ukuran maksimum. Script menggunakan perintah yang disebutkan dalam jawaban lain. Karena ini adalah skrip shell kepalan tanganku dengan ukuran ini, aku butuh waktu berjam-jam untuk membuatnya dan itu bukan jet sempurna. Terutama saya tidak tahu bagaimana menangani nilai kembali dari resize2fs dan fdisk sehingga pengguna harus mengetikkan nilai yang saya butuhkan. Apakah ada ide untuk memperbaikinya? Saya harap skrip ini membantu orang lain. Jangan ragu untuk mengedit dan memperbaikinya.

"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

ini dia:

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

Solusi termudah yang saya temukan adalah melakukan pencadangan kartu yang lebih besar asli menggunakan perintah dd yang diuraikan di atas dan kemudian mengembalikan gambar ke kartu yang lebih kecil menggunakan sesuatu seperti penulis naskah. dd mungkin bekerja juga ... tidak yakin. PiWriter mengembalikan kesalahan karena kehabisan ruang, tetapi karena gambar tidak berisi data aktual di luar ukuran kartu yang lebih kecil itu hanya memotong sektor kosong. Saya tidak yakin apa implikasi dari ini adalah ... partisi mungkin perlu diperiksa atau diperbaiki tetapi saya dapat memverifikasi bahwa itu berhasil ketika saya memasukkannya ke dalam Pi.

Saya menggunakan versi lama win32diskimager-RELEASE-0.1-r15-win32untuk membaca gambar, itu menciptakan gambar 4GB bahkan dari kartu SD 8GB dan kemudian menulis gambar dengan versi terbaru win32diskimager.

Saya menggunakan versi yang lebih lama karena yang lama akan melewatkan setiap kesalahan.