···

       
15
       
 
       


     

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

     

       
17
       
 
       
  # either "efi" or "hybrid"

     

       
0
       
 
       

     

       
0
       
 
       

     

       
18
       
 
       
  bootSize ? "256M"

     

       
19
       
 
       


     

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

     
···

       
163
       
 
       


     

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

     

       
165
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
166
       
 
       
  prepareImage = ''

     

       
167
       
 
       
    export PATH=${binPath}

     

       
168
       
 
       


     
···

       
173
       
 
       


     

       
174
       
 
       
    sectorsToBytes() {

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
176
       
 
       
    }

     

       
177
       
 
       


     

       
178
       
 
       
    mkdir $out

     
···

       
235
       
 
       


     

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

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
239
       
 
       
      '' else ''

     

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

     

       
241
       
 
       
      ''}

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
244
       
 
       
    '' else ''

     

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

     

       
246
       
 
       
    ''}

     
···

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

     

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

     

       
253
       
 
       


     

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

     

       
255
       
 
       
    '' else ''

     

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

     

       
257
       
 
       
    ''}

     

       
258
       
 
       


     

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

     

···

       
15
       
 
       


     

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

     

       
17
       
 
       
  # either "efi" or "hybrid"

     

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

     

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

     

       
20
       
 
       
  bootSize ? "256M"

     

       
21
       
 
       


     

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

     
···

       
165
       
 
       


     

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

     

       
167
       
 
       


     

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

     

       
169
       
+
       


     

       
170
       
 
       
  prepareImage = ''

     

       
171
       
 
       
    export PATH=${binPath}

     

       
172
       
 
       


     
···

       
177
       
 
       


     

       
178
       
 
       
    sectorsToBytes() {

     

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

     

       
180
       
+
       
    }

     

       
181
       
+
       


     

       
182
       
+
       
    # Given lines of numbers, adds them together

     

       
183
       
+
       
    sum_lines() {

     

       
184
       
+
       
      local acc=0

     

       
185
       
+
       
      while read -r number; do

     

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

     

       
187
       
+
       
      done

     

       
188
       
+
       
      echo "$acc"

     

       
189
       
+
       
    }

     

       
190
       
+
       


     

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

     

       
192
       
+
       


     

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

     

       
194
       
+
       
    # 0.05208587646484375

     

       
195
       
+
       
    #  × 1000, integer part: 52

     

       
196
       
+
       
    compute_fudge() {

     

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

     

       
198
       
 
       
    }

     

       
199
       
 
       


     

       
200
       
 
       
    mkdir $out

     
···

       
257
       
 
       


     

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

     

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

     

       
260
       
+
       
        # Add the GPT at the end

     

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

     

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

     

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

     

       
264
       
+
       
        # represents the offset at which it ends.

     

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

     

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

     

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

     

       
268
       
+
       
        # Add the GPT at the end

     

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

     

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

     

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

     

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

     

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

     

       
274
       
+
       
        reservedSpace=$(( mebibyte ))

     

       
275
       
 
       
      '' else ''

     

       
276
       
+
       
        reservedSpace=0

     

       
277
       
 
       
      ''}

     

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

     

       
279
       
+
       


     

       
280
       
+
       
      # Compute required space in filesystem blocks

     

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

     

       
282
       
+
       
      # Each inode takes space!

     

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

     

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

     

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

     

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

     

       
287
       
+
       
      fudge=$(compute_fudge $diskUsage)

     

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

     

       
289
       
+
       


     

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

     

       
291
       
+
       


     

       
292
       
+
       
      # Round up to the nearest mebibyte.

     

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

     

       
294
       
+
       
      # and helps towards aligning partitions optimally.

     

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

     

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

     

       
297
       
+
       
      fi

     

       
298
       
+
       


     

       
299
       
+
       
      truncate -s "$diskSize" $diskImage

     

       
300
       
+
       


     

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

     

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

     

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

     

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

     

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

     

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

     

       
307
       
 
       
    '' else ''

     

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

     

       
309
       
 
       
    ''}

     
···

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

     

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

     

       
316
       
 
       


     

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

     

       
318
       
 
       
    '' else ''

     

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

     

       
320
       
 
       
    ''}

     

       
321
       
 
       


     

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

     

···

       
10
       
 
       


     

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

     

       
12
       
 
       
    inherit lib config pkgs;

     

       
13
       
-
       
    diskSize = 8192;

     

       
14
       
 
       
    format = "qcow2";

     

       
15
       
 
       
    configFile = pkgs.writeText "configuration.nix"

     

       
16
       
 
       
      ''

     

···

       
10
       
 
       


     

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

     

       
12
       
 
       
    inherit lib config pkgs;

     

       
0
       
 
       

     

       
13
       
 
       
    format = "qcow2";

     

       
14
       
 
       
    configFile = pkgs.writeText "configuration.nix"

     

       
15
       
 
       
      ''

     

···

       
40
       
 
       
    };

     

       
41
       
 
       


     

       
42
       
 
       
    sizeMB = mkOption {

     

       
43
       
-
       
      type = types.int;

     

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

     

       
0
       
 
       

     

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

     

       
46
       
 
       
    };

     

       
47
       
 
       


     

···

       
40
       
 
       
    };

     

       
41
       
 
       


     

       
42
       
 
       
    sizeMB = mkOption {

     

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

     

       
44
       
+
       
      default = "auto";

     

       
45
       
+
       
      example = 8192;

     

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

     

       
47
       
 
       
    };

     

       
48
       
 
       


     

···

       
12
       
 
       


     

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

     

       
14
       
 
       
    inherit lib config;

     

       
0
       
 
       

     

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

     

       
16
       
-
       
    diskSize = 8192;

     

       
17
       
 
       
    format = "qcow2";

     

       
18
       
 
       
    configFile = pkgs.writeText "configuration.nix"

     

       
19
       
 
       
      ''

     

···

       
12
       
 
       


     

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

     

       
14
       
 
       
    inherit lib config;

     

       
15
       
+
       
    additionalSpace = "1024M";

     

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

     

       
0
       
 
       

     

       
17
       
 
       
    format = "qcow2";

     

       
18
       
 
       
    configFile = pkgs.writeText "configuration.nix"

     

       
19
       
 
       
      ''

     

···

       
9
       
 
       


     

       
10
       
 
       
  options = {

     

       
11
       
 
       
    virtualisation.azureImage.diskSize = mkOption {

     

       
12
       
-
       
      type = with types; int;

     

       
13
       
-
       
      default = 2048;

     

       
0
       
 
       

     

       
14
       
 
       
      description = ''

     

       
15
       
 
       
        Size of disk image. Unit is MB.

     

       
16
       
 
       
      '';

     

···

       
9
       
 
       


     

       
10
       
 
       
  options = {

     

       
11
       
 
       
    virtualisation.azureImage.diskSize = mkOption {

     

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

     

       
13
       
+
       
      default = "auto";

     

       
14
       
+
       
      example = 2048;

     

       
15
       
 
       
      description = ''

     

       
16
       
 
       
        Size of disk image. Unit is MB.

     

       
17
       
 
       
      '';

     

···

       
10
       
 
       


     

       
11
       
 
       
  options = {

     

       
12
       
 
       
    virtualisation.digitalOceanImage.diskSize = mkOption {

     

       
13
       
-
       
      type = with types; int;

     

       
14
       
-
       
      default = 4096;

     

       
0
       
 
       

     

       
15
       
 
       
      description = ''

     

       
16
       
 
       
        Size of disk image. Unit is MB.

     

       
17
       
 
       
      '';

     

···

       
10
       
 
       


     

       
11
       
 
       
  options = {

     

       
12
       
 
       
    virtualisation.digitalOceanImage.diskSize = mkOption {

     

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

     

       
14
       
+
       
      default = "auto";

     

       
15
       
+
       
      example = 4096;

     

       
16
       
 
       
      description = ''

     

       
17
       
 
       
        Size of disk image. Unit is MB.

     

       
18
       
 
       
      '';

     

···

       
18
       
 
       


     

       
19
       
 
       
  options = {

     

       
20
       
 
       
    virtualisation.googleComputeImage.diskSize = mkOption {

     

       
21
       
-
       
      type = with types; int;

     

       
22
       
-
       
      default = 1536;

     

       
0
       
 
       

     

       
23
       
 
       
      description = ''

     

       
24
       
 
       
        Size of disk image. Unit is MB.

     

       
25
       
 
       
      '';

     

···

       
18
       
 
       


     

       
19
       
 
       
  options = {

     

       
20
       
 
       
    virtualisation.googleComputeImage.diskSize = mkOption {

     

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

     

       
22
       
+
       
      default = "auto";

     

       
23
       
+
       
      example = 1536;

     

       
24
       
 
       
      description = ''

     

       
25
       
 
       
        Size of disk image. Unit is MB.

     

       
26
       
 
       
      '';

     

···

       
9
       
 
       
  options = {

     

       
10
       
 
       
    hyperv = {

     

       
11
       
 
       
      baseImageSize = mkOption {

     

       
12
       
-
       
        type = types.int;

     

       
13
       
-
       
        default = 2048;

     

       
0
       
 
       

     

       
14
       
 
       
        description = ''

     

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

     

       
16
       
 
       
        '';

     

···

       
9
       
 
       
  options = {

     

       
10
       
 
       
    hyperv = {

     

       
11
       
 
       
      baseImageSize = mkOption {

     

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

     

       
13
       
+
       
        default = "auto";

     

       
14
       
+
       
        example = 2048;

     

       
15
       
 
       
        description = ''

     

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

     

       
17
       
 
       
        '';

     

···

       
11
       
 
       
  options = {

     

       
12
       
 
       
    virtualbox = {

     

       
13
       
 
       
      baseImageSize = mkOption {

     

       
14
       
-
       
        type = types.int;

     

       
15
       
-
       
        default = 50 * 1024;

     

       
0
       
 
       

     

       
16
       
 
       
        description = ''

     

       
17
       
 
       
          The size of the VirtualBox base image in MiB.

     

       
18
       
 
       
        '';

     

···

       
11
       
 
       
  options = {

     

       
12
       
 
       
    virtualbox = {

     

       
13
       
 
       
      baseImageSize = mkOption {

     

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

     

       
15
       
+
       
        default = "auto";

     

       
16
       
+
       
        example = 50 * 1024;

     

       
17
       
 
       
        description = ''

     

       
18
       
 
       
          The size of the VirtualBox base image in MiB.

     

       
19
       
 
       
        '';

     

···

       
18
       
 
       
  options = {

     

       
19
       
 
       
    vmware = {

     

       
20
       
 
       
      baseImageSize = mkOption {

     

       
21
       
-
       
        type = types.int;

     

       
22
       
-
       
        default = 2048;

     

       
0
       
 
       

     

       
23
       
 
       
        description = ''

     

       
24
       
 
       
          The size of the VMWare base image in MiB.

     

       
25
       
 
       
        '';

     

···

       
18
       
 
       
  options = {

     

       
19
       
 
       
    vmware = {

     

       
20
       
 
       
      baseImageSize = mkOption {

     

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

     

       
22
       
+
       
        default = "auto";

     

       
23
       
+
       
        example = 2048;

     

       
24
       
 
       
        description = ''

     

       
25
       
 
       
          The size of the VMWare base image in MiB.

     

       
26
       
 
       
        '';