commit 773cbfbd2886b8f58a37f2f665122dcf83576f70 · pyrox.dev/nixpkgs

nixos/lib/make-ext4-fs.nix

···

       78
       78
        
             # get rid of the unnecessary slack here--but see

     

       79
       79
        
             # https://github.com/NixOS/nixpkgs/issues/125121 for caveats.

     

       80
       80
        
       

     

       81
       81
       +
             # shrink to fit

     

       82
       82
       +
             resize2fs -M $img

     

       83
       83
       +
       

     

       84
       84
       +
             # Add 16 MebiByte to the current_size

     

       85
       85
       +
             new_size=$(dumpe2fs -h $img | awk -F: \

     

       86
       86
       +
               '/Block count/{count=$2} /Block size/{size=$2} END{print (count*size+16*2**20)/size}')

     

       87
       87
       +
       

     

       88
       88
       +
             resize2fs $img $new_size

     

       89
       89
       +
       

     

       81
       90
        
             if [ ${builtins.toString compressImage} ]; then

     

       82
       91
        
               echo "Compressing image"

     

       83
       92
        
               zstd -v --no-progress ./$img -o $out

+10 -5

nixos/modules/installer/sd-card/sd-image.nix

···

       18
       18
        
       let

     

       19
       19
        
         rootfsImage = pkgs.callPackage ../../../lib/make-ext4-fs.nix ({

     

       20
       20
        
           inherit (config.sdImage) storePaths;

     

       21
       21
       -
           compressImage = true;

     

       21
       21
       +
           compressImage = config.sdImage.compressImage;

     

       22
       22
        
           populateImageCommands = config.sdImage.populateRootCommands;

     

       23
       23
        
           volumeLabel = "NIXOS_SD";

     

       24
       24
        
         } // optionalAttrs (config.sdImage.rootPartitionUUID != null) {

     
···

       174
       174
        
           mtools, libfaketime, util-linux, zstd }: stdenv.mkDerivation {

     

       175
       175
        
             name = config.sdImage.imageName;

     

       176
       176
        
       

     

       177
       177
       -
             nativeBuildInputs = [ dosfstools e2fsprogs mtools libfaketime util-linux zstd ];

     

       177
       177
       +
             nativeBuildInputs = [ dosfstools e2fsprogs libfaketime mtools util-linux ]

     

       178
       178
       +
             ++ lib.optional config.sdImage.compressImage zstd;

     

       178
       179
        
       

     

       179
       180
        
             inherit (config.sdImage) imageName compressImage;

     

       180
       181
        
       

     
···

       189
       190
        
                 echo "file sd-image $img" >> $out/nix-support/hydra-build-products

     

       190
       191
        
               fi

     

       191
       192
        
       

     

       193
       193
       +
               root_fs=${rootfsImage}

     

       194
       194
       +
               ${lib.optionalString config.sdImage.compressImage ''

     

       195
       195
       +
               root_fs=./root-fs.img

     

       192
       196
        
               echo "Decompressing rootfs image"

     

       193
       193
       -
               zstd -d --no-progress "${rootfsImage}" -o ./root-fs.img

     

       197
       197
       +
               zstd -d --no-progress "${rootfsImage}" -o $root_fs

     

       198
       198
       +
               ''}

     

       194
       199
        
       

     

       195
       200
        
               # Gap in front of the first partition, in MiB

     

       196
       201
        
               gap=${toString config.sdImage.firmwarePartitionOffset}

     

       197
       202
        
       

     

       198
       203
        
               # Create the image file sized to fit /boot/firmware and /, plus slack for the gap.

     

       199
       199
       -
               rootSizeBlocks=$(du -B 512 --apparent-size ./root-fs.img | awk '{ print $1 }')

     

       204
       204
       +
               rootSizeBlocks=$(du -B 512 --apparent-size $root_fs | awk '{ print $1 }')

     

       200
       205
        
               firmwareSizeBlocks=$((${toString config.sdImage.firmwareSize} * 1024 * 1024 / 512))

     

       201
       206
        
               imageSize=$((rootSizeBlocks * 512 + firmwareSizeBlocks * 512 + gap * 1024 * 1024))

     

       202
       207
        
               truncate -s $imageSize $img

     
···

       214
       219
        
       

     

       215
       220
        
               # Copy the rootfs into the SD image

     

       216
       221
        
               eval $(partx $img -o START,SECTORS --nr 2 --pairs)

     

       217
       217
       -
               dd conv=notrunc if=./root-fs.img of=$img seek=$START count=$SECTORS

     

       222
       222
       +
               dd conv=notrunc if=$root_fs of=$img seek=$START count=$SECTORS

     

       218
       223
        
       

     

       219
       224
        
               # Create a FAT32 /boot/firmware partition of suitable size into firmware_part.img

     

       220
       225
        
               eval $(partx $img -o START,SECTORS --nr 1 --pairs)