commit ee04d772e494e66c3748de3ba4620a35176172e7 · pyrox.dev/nixpkgs

+69 -6

nixos/lib/make-disk-image.nix

···

       15
       15
        
       

     

       16
       16
        
       , # size of the boot partition, is only used if partitionTableType is

     

       17
       17
        
         # either "efi" or "hybrid"

     

       18
       18
       +
         # This will be undersized slightly, as this is actually the offset of

     

       19
       19
       +
         # the end of the partition. Generally it will be 1MiB smaller.

     

       18
       20
        
         bootSize ? "256M"

     

       19
       21
        
       

     

       20
       22
        
       , # The files and directories to be placed in the target file system.

     
···

       163
       165
        
       

     

       164
       166
        
         closureInfo = pkgs.closureInfo { rootPaths = [ config.system.build.toplevel channelSources ]; };

     

       165
       167
        
       

     

       168
       168
       +
         blockSize = toString (4 * 1024); # ext4fs block size (not block device sector size)

     

       169
       169
       +
       

     

       166
       170
        
         prepareImage = ''

     

       167
       171
        
           export PATH=${binPath}

     

       168
       172
        
       

     
···

       173
       177
        
       

     

       174
       178
        
           sectorsToBytes() {

     

       175
       179
        
             echo $(( "$1" * 512  ))

     

       180
       180
       +
           }

     

       181
       181
       +
       

     

       182
       182
       +
           # Given lines of numbers, adds them together

     

       183
       183
       +
           sum_lines() {

     

       184
       184
       +
             local acc=0

     

       185
       185
       +
             while read -r number; do

     

       186
       186
       +
               acc=$((acc+number))

     

       187
       187
       +
             done

     

       188
       188
       +
             echo "$acc"

     

       189
       189
       +
           }

     

       190
       190
       +
       

     

       191
       191
       +
           mebibyte=$(( 1024 * 1024 ))

     

       192
       192
       +
       

     

       193
       193
       +
           # Approximative percentage of reserved space in an ext4 fs over 512MiB.

     

       194
       194
       +
           # 0.05208587646484375

     

       195
       195
       +
           #  × 1000, integer part: 52

     

       196
       196
       +
           compute_fudge() {

     

       197
       197
       +
             echo $(( $1 * 52 / 1000 ))

     

       176
       198
        
           }

     

       177
       199
        
       

     

       178
       200
        
           mkdir $out

     
···

       235
       257
        
       

     

       236
       258
        
           ${if diskSize == "auto" then ''

     

       237
       259
        
             ${if partitionTableType == "efi" || partitionTableType == "hybrid" then ''

     

       238
       238
       -
               additionalSpace=$(( ($(numfmt --from=iec '${additionalSpace}') + $(numfmt --from=iec '${bootSize}')) / 1000 ))

     

       260
       260
       +
               # Add the GPT at the end

     

       261
       261
       +
               gptSpace=$(( 512 * 34 * 1 ))

     

       262
       262
       +
               # Normally we'd need to account for alignment and things, if bootSize

     

       263
       263
       +
               # represented the actual size of the boot partition. But it instead

     

       264
       264
       +
               # represents the offset at which it ends.

     

       265
       265
       +
               # So we know bootSize is the reserved space in front of the partition.

     

       266
       266
       +
               reservedSpace=$(( gptSpace + $(numfmt --from=iec '${bootSize}') ))

     

       267
       267
       +
             '' else if partitionTableType == "legacy+gpt" then ''

     

       268
       268
       +
               # Add the GPT at the end

     

       269
       269
       +
               gptSpace=$(( 512 * 34 * 1 ))

     

       270
       270
       +
               # And include the bios_grub partition; the ext4 partition starts at 2MB exactly.

     

       271
       271
       +
               reservedSpace=$(( gptSpace + 2 * mebibyte ))

     

       272
       272
       +
             '' else if partitionTableType == "legacy" then ''

     

       273
       273
       +
               # Add the 1MiB aligned reserved space (includes MBR)

     

       274
       274
       +
               reservedSpace=$(( mebibyte ))

     

       239
       275
        
             '' else ''

     

       240
       240
       -
               additionalSpace=$(( $(numfmt --from=iec '${additionalSpace}') / 1000 ))

     

       276
       276
       +
               reservedSpace=0

     

       241
       277
        
             ''}

     

       242
       242
       -
             diskSize=$(( $(set -- $(du -d0 $root); echo "$1") + $additionalSpace ))

     

       243
       243
       -
             truncate -s "$diskSize"K $diskImage

     

       278
       278
       +
             additionalSpace=$(( $(numfmt --from=iec '${additionalSpace}') + reservedSpace ))

     

       279
       279
       +
       

     

       280
       280
       +
             # Compute required space in filesystem blocks

     

       281
       281
       +
             diskUsage=$(find . ! -type d -exec 'du' '--apparent-size' '--block-size' "${blockSize}" '{}' ';' | cut -f1 | sum_lines)

     

       282
       282
       +
             # Each inode takes space!

     

       283
       283
       +
             numInodes=$(find . | wc -l)

     

       284
       284
       +
             # Convert to bytes, inodes take two blocks each!

     

       285
       285
       +
             diskUsage=$(( (diskUsage + 2 * numInodes) * ${blockSize} ))

     

       286
       286
       +
             # Then increase the required space to account for the reserved blocks.

     

       287
       287
       +
             fudge=$(compute_fudge $diskUsage)

     

       288
       288
       +
             requiredFilesystemSpace=$(( diskUsage + fudge ))

     

       289
       289
       +
       

     

       290
       290
       +
             diskSize=$(( requiredFilesystemSpace  + additionalSpace ))

     

       291
       291
       +
       

     

       292
       292
       +
             # Round up to the nearest mebibyte.

     

       293
       293
       +
             # This ensures whole 512 bytes sector sizes in the disk image

     

       294
       294
       +
             # and helps towards aligning partitions optimally.

     

       295
       295
       +
             if (( diskSize % mebibyte )); then

     

       296
       296
       +
               diskSize=$(( ( diskSize / mebibyte + 1) * mebibyte ))

     

       297
       297
       +
             fi

     

       298
       298
       +
       

     

       299
       299
       +
             truncate -s "$diskSize" $diskImage

     

       300
       300
       +
       

     

       301
       301
       +
             printf "Automatic disk size...\n"

     

       302
       302
       +
             printf "  Closure space use: %d bytes\n" $diskUsage

     

       303
       303
       +
             printf "  fudge: %d bytes\n" $fudge

     

       304
       304
       +
             printf "  Filesystem size needed: %d bytes\n" $requiredFilesystemSpace

     

       305
       305
       +
             printf "  Additional space: %d bytes\n" $additionalSpace

     

       306
       306
       +
             printf "  Disk image size: %d bytes\n" $diskSize

     

       244
       307
        
           '' else ''

     

       245
       308
        
             truncate -s ${toString diskSize}M $diskImage

     

       246
       309
        
           ''}

     
···

       251
       314
        
             # Get start & length of the root partition in sectors to $START and $SECTORS.

     

       252
       315
        
             eval $(partx $diskImage -o START,SECTORS --nr ${rootPartition} --pairs)

     

       253
       316
        
       

     

       254
       254
       -
             mkfs.${fsType} -F -L ${label} $diskImage -E offset=$(sectorsToBytes $START) $(sectorsToKilobytes $SECTORS)K

     

       317
       317
       +
             mkfs.${fsType} -b ${blockSize} -F -L ${label} $diskImage -E offset=$(sectorsToBytes $START) $(sectorsToKilobytes $SECTORS)K

     

       255
       318
        
           '' else ''

     

       256
       256
       -
             mkfs.${fsType} -F -L ${label} $diskImage

     

       319
       319
       +
             mkfs.${fsType} -b ${blockSize} -F -L ${label} $diskImage

     

       257
       320
        
           ''}

     

       258
       321
        
       

     

       259
       322
        
           echo "copying staging root to image..."

-1

nixos/maintainers/scripts/cloudstack/cloudstack-image.nix

···

       10
       10
        
       

     

       11
       11
        
         system.build.cloudstackImage = import ../../../lib/make-disk-image.nix {

     

       12
       12
        
           inherit lib config pkgs;

     

       13
       13
       -
           diskSize = 8192;

     

       14
       13
        
           format = "qcow2";

     

       15
       14
        
           configFile = pkgs.writeText "configuration.nix"

     

       16
       15
        
             ''

+3 -2

nixos/maintainers/scripts/ec2/amazon-image.nix

···

       40
       40
        
           };

     

       41
       41
        
       

     

       42
       42
        
           sizeMB = mkOption {

     

       43
       43
       -
             type = types.int;

     

       44
       44
       -
             default = if config.ec2.hvm then 2048 else 8192;

     

       43
       43
       +
             type = with types; either (enum [ "auto" ]) int;

     

       44
       44
       +
             default = "auto";

     

       45
       45
       +
             example = 8192;

     

       45
       46
        
             description = "The size in MB of the image";

     

       46
       47
        
           };

     

       47
       48

+1 -1

nixos/maintainers/scripts/openstack/openstack-image.nix

···

       12
       12
        
       

     

       13
       13
        
         system.build.openstackImage = import ../../../lib/make-disk-image.nix {

     

       14
       14
        
           inherit lib config;

     

       15
       15
       +
           additionalSpace = "1024M";

     

       15
       16
        
           pkgs = import ../../../.. { inherit (pkgs) system; }; # ensure we use the regular qemu-kvm package

     

       16
       16
       -
           diskSize = 8192;

     

       17
       17
        
           format = "qcow2";

     

       18
       18
        
           configFile = pkgs.writeText "configuration.nix"

     

       19
       19
        
             ''

+3 -2

nixos/modules/virtualisation/azure-image.nix

···

       9
       9
        
       

     

       10
       10
        
         options = {

     

       11
       11
        
           virtualisation.azureImage.diskSize = mkOption {

     

       12
       12
       -
             type = with types; int;

     

       13
       13
       -
             default = 2048;

     

       12
       12
       +
             type = with types; either (enum [ "auto" ]) int;

     

       13
       13
       +
             default = "auto";

     

       14
       14
       +
             example = 2048;

     

       14
       15
        
             description = ''

     

       15
       16
        
               Size of disk image. Unit is MB.

     

       16
       17
        
             '';

+3 -2

nixos/modules/virtualisation/digital-ocean-image.nix

···

       10
       10
        
       

     

       11
       11
        
         options = {

     

       12
       12
        
           virtualisation.digitalOceanImage.diskSize = mkOption {

     

       13
       13
       -
             type = with types; int;

     

       14
       14
       -
             default = 4096;

     

       13
       13
       +
             type = with types; either (enum [ "auto" ]) int;

     

       14
       14
       +
             default = "auto";

     

       15
       15
       +
             example = 4096;

     

       15
       16
        
             description = ''

     

       16
       17
        
               Size of disk image. Unit is MB.

     

       17
       18
        
             '';

+3 -2

nixos/modules/virtualisation/google-compute-image.nix

···

       18
       18
        
       

     

       19
       19
        
         options = {

     

       20
       20
        
           virtualisation.googleComputeImage.diskSize = mkOption {

     

       21
       21
       -
             type = with types; int;

     

       22
       22
       -
             default = 1536;

     

       21
       21
       +
             type = with types; either (enum [ "auto" ]) int;

     

       22
       22
       +
             default = "auto";

     

       23
       23
       +
             example = 1536;

     

       23
       24
        
             description = ''

     

       24
       25
        
               Size of disk image. Unit is MB.

     

       25
       26
        
             '';

+3 -2

nixos/modules/virtualisation/hyperv-image.nix

···

       9
       9
        
         options = {

     

       10
       10
        
           hyperv = {

     

       11
       11
        
             baseImageSize = mkOption {

     

       12
       12
       -
               type = types.int;

     

       13
       13
       -
               default = 2048;

     

       12
       12
       +
               type = with types; either (enum [ "auto" ]) int;

     

       13
       13
       +
               default = "auto";

     

       14
       14
       +
               example = 2048;

     

       14
       15
        
               description = ''

     

       15
       16
        
                 The size of the hyper-v base image in MiB.

     

       16
       17
        
               '';

+3 -2

nixos/modules/virtualisation/virtualbox-image.nix

···

       11
       11
        
         options = {

     

       12
       12
        
           virtualbox = {

     

       13
       13
        
             baseImageSize = mkOption {

     

       14
       14
       -
               type = types.int;

     

       15
       15
       -
               default = 50 * 1024;

     

       14
       14
       +
               type = with types; either (enum [ "auto" ]) int;

     

       15
       15
       +
               default = "auto";

     

       16
       16
       +
               example = 50 * 1024;

     

       16
       17
        
               description = ''

     

       17
       18
        
                 The size of the VirtualBox base image in MiB.

     

       18
       19
        
               '';

+3 -2

nixos/modules/virtualisation/vmware-image.nix

···

       18
       18
        
         options = {

     

       19
       19
        
           vmware = {

     

       20
       20
        
             baseImageSize = mkOption {

     

       21
       21
       -
               type = types.int;

     

       22
       22
       -
               default = 2048;

     

       21
       21
       +
               type = with types; either (enum [ "auto" ]) int;

     

       22
       22
       +
               default = "auto";

     

       23
       23
       +
               example = 2048;

     

       23
       24
        
               description = ''

     

       24
       25
        
                 The size of the VMWare base image in MiB.

     

       25
       26
        
               '';