commit 8279ffe622b81efd199d43445236b3bcb362a99b · pyrox.dev/nixpkgs

+2 -2

doc/build-helpers/images/dockertools.section.md

···

       145
       145
        
       

     

       146
       146
        
       `diskSize` (Number; _optional_)

     

       147
       147
        
       

     

       148
       148
       -
       : Controls the disk size (in megabytes) of the VM used to run the script specified in `runAsRoot`.

     

       148
       148
       +
       : Controls the disk size in MiB (1024x1024 bytes) of the VM used to run the script specified in `runAsRoot`.

     

       149
       149
        
         This attribute is ignored if `runAsRoot` is `null`.

     

       150
       150
        
       

     

       151
       151
        
         _Default value:_ 1024.

     

       152
       152
        
       

     

       153
       153
        
       `buildVMMemorySize` (Number; _optional_)

     

       154
       154
        
       

     

       155
       155
       -
       : Controls the amount of memory (in megabytes) provisioned for the VM used to run the script specified in `runAsRoot`.

     

       155
       155
       +
       : Controls the amount of memory in MiB (1024x1024 bytes) provisioned for the VM used to run the script specified in `runAsRoot`.

     

       156
       156
        
         This attribute is ignored if `runAsRoot` is `null`.

     

       157
       157
        
       

     

       158
       158
        
         _Default value:_ 512.

+1 -1

doc/build-helpers/images/makediskimage.section.md

···

       108
       108
        
         diskSize = "auto";

     

       109
       109
        
         additionalSpace = "0M"; # Defaults to 512M.

     

       110
       110
        
         copyChannel = false;

     

       111
       111
       -
         memSize = 2048; # Qemu VM memory size in megabytes. Defaults to 1024M.

     

       111
       111
       +
         memSize = 2048; # Qemu VM memory size in MiB (1024*1024 bytes). Defaults to 1024M.

     

       112
       112
        
       }

     

       113
       113
        
       ```

+1 -1

doc/build-helpers/special/vm-tools.section.md

···

       23
       23
        
       ### Attributes {#vm-tools-runInLinuxVM-attributes}

     

       24
       24
        
       

     

       25
       25
        
       * `preVM` (optional). Shell command to be evaluated *before* the VM is started (i.e., on the host).

     

       26
       26
       -
       * `memSize` (optional, default `512`). The memory size of the VM in MiB.

     

       26
       26
       +
       * `memSize` (optional, default `512`). The memory size of the VM in MiB (1024×1024 bytes).

     

       27
       27
        
       * `diskImage` (optional). A file system image to be attached to `/dev/sda`.

     

       28
       28
        
         Note that currently we expect the image to contain a filesystem, not a full disk image with a partition table etc.

     

       29
       29

+1 -1

nixos/doc/manual/development/writing-nixos-tests.section.md

···

       92
       92
        
       

     

       93
       93
        
       `virtualisation.memorySize`

     

       94
       94
        
       

     

       95
       95
       -
       :   The memory of the VM in megabytes.

     

       95
       95
       +
       :   The memory of the VM in MiB (1024×1024 bytes).

     

       96
       96
        
       

     

       97
       97
        
       `virtualisation.vlans`

     

       98
       98

+2 -2

nixos/lib/make-disk-image.nix

···

       104
       104
        
         # The NixOS configuration to be installed onto the disk image.

     

       105
       105
        
         config,

     

       106
       106
        
       

     

       107
       107
       -
         # The size of the disk, in megabytes.

     

       107
       107
       +
         # The size of the disk, in MiB (1024*1024 bytes).

     

       108
       108
        
         # if "auto" size is calculated based on the contents copied to it and

     

       109
       109
        
         #   additionalSpace is taken into account.

     

       110
       110
        
         diskSize ? "auto",

     
···

       160
       160
        
         # Shell code executed after the VM has finished.

     

       161
       161
        
         postVM ? "",

     

       162
       162
        
       

     

       163
       163
       -
         # Guest memory size

     

       163
       163
       +
         # Guest memory size in MiB (1024*1024 bytes)

     

       164
       164
        
         memSize ? 1024,

     

       165
       165
        
       

     

       166
       166
        
         # Copy the contents of the Nix store to the root of the image and

+3 -3

nixos/lib/make-multi-disk-zfs-image.nix

···

       30
       30
        
         # The NixOS configuration to be installed onto the disk image.

     

       31
       31
        
         config,

     

       32
       32
        
       

     

       33
       33
       -
         # size of the FAT boot disk, in megabytes.

     

       33
       33
       +
         # size of the FAT boot disk in MiB (1024*1024 bytes)

     

       34
       34
        
         bootSize ? 1024,

     

       35
       35
        
       

     

       36
       36
       -
         # The size of the root disk, in megabytes.

     

       36
       36
       +
         # The size of the root disk in MiB (1024*1024 bytes)

     

       37
       37
        
         rootSize ? 2048,

     

       38
       38
        
       

     

       39
       39
        
         # The name of the ZFS pool

     
···

       74
       74
        
         # Shell code executed after the VM has finished.

     

       75
       75
        
         postVM ? "",

     

       76
       76
        
       

     

       77
       77
       -
         # Guest memory size

     

       77
       77
       +
         # Guest memory size in MiB (1024*1024 bytes)

     

       78
       78
        
         memSize ? 1024,

     

       79
       79
        
       

     

       80
       80
        
         name ? "nixos-disk-image",

+4 -4

nixos/lib/make-single-disk-zfs-image.nix

···

       19
       19
        
         # The NixOS configuration to be installed onto the disk image.

     

       20
       20
        
         config,

     

       21
       21
        
       

     

       22
       22
       -
         # size of the FAT partition, in megabytes.

     

       23
       23
       -
         bootSize ? 1024

     

       22
       22
       +
         # size of the FAT partition, in MiB (1024x1024 bytes).

     

       23
       23
       +
         bootSize ? 1024,

     

       24
       24
        
       

     

       25
       25
       -
         , # memory allocated for virtualized build instance

     

       25
       25
       +
         # memory allocated for virtualized build instance, in MiB (1024x1024 bytes).

     

       26
       26
        
         memSize ? 1024,

     

       27
       27
        
       

     

       28
       28
       -
         # The size of the root partition, in megabytes.

     

       28
       28
       +
         # The size of the root partition, in MiB (1024x1024 bytes).

     

       29
       29
        
         rootSize ? 2048,

     

       30
       30
        
       

     

       31
       31
        
         # The name of the ZFS pool

+1 -1

nixos/modules/config/swap.nix

···

       121
       121
        
                 description = ''

     

       122
       122
        
                   If this option is set, ‘device’ is interpreted as the

     

       123
       123
        
                   path of a swapfile that will be created automatically

     

       124
       124
       -
                   with the indicated size (in megabytes).

     

       124
       124
       +
                   with the indicated size in MiB (1024×1024 bytes).

     

       125
       125
        
                 '';

     

       126
       126
        
               };

     

       127
       127

+1 -2

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

···

       80
       80
        
             type = types.int;

     

       81
       81
        
             default = 8;

     

       82
       82
        
             description = ''

     

       83
       83
       -
               Gap in front of the /boot/firmware partition, in mebibytes (1024×1024

     

       84
       84
       -
               bytes).

     

       83
       83
       +
               Gap in front of the /boot/firmware partition, in MiB (1024×1024 bytes).

     

       85
       84
        
               Can be increased to make more space for boards requiring to dd u-boot

     

       86
       85
        
               SPL before actual partitions.

     

       87
       86

+2 -2

nixos/modules/profiles/nix-builder-vm.nix

···

       48
       48
        
             default = 20 * 1024;

     

       49
       49
        
             type = types.int;

     

       50
       50
        
             example = 30720;

     

       51
       51
       -
             description = "The maximum disk space allocated to the runner in MB";

     

       51
       51
       +
             description = "The maximum disk space allocated to the runner in MiB (1024×1024 bytes).";

     

       52
       52
        
           };

     

       53
       53
        
           memorySize = mkOption {

     

       54
       54
        
             default = 3 * 1024;

     

       55
       55
        
             type = types.int;

     

       56
       56
        
             example = 8192;

     

       57
       57
       -
             description = "The runner's memory in MB";

     

       57
       57
       +
             description = "The runner's memory in MiB (1024×1024 bytes).";

     

       58
       58
        
           };

     

       59
       59
        
           min-free = mkOption {

     

       60
       60
        
             default = 1024 * 1024 * 1024;

+1 -1

nixos/modules/services/databases/memcached.nix

···

       44
       44
        
             maxMemory = lib.mkOption {

     

       45
       45
        
               type = lib.types.ints.unsigned;

     

       46
       46
        
               default = 64;

     

       47
       47
       -
               description = "The maximum amount of memory to use for storage, in megabytes.";

     

       47
       47
       +
               description = "The maximum amount of memory to use for storage, in MiB (1024×1024 bytes).";

     

       48
       48
        
             };

     

       49
       49
        
       

     

       50
       50
        
             maxConnections = lib.mkOption {

+1 -1

nixos/modules/virtualisation/disk-size-option.nix

···

       18
       18
        
             default = if config.virtualisation.diskSizeAutoSupported then "auto" else 1024;

     

       19
       19
        
             defaultText = lib.literalExpression "if virtualisation.diskSizeAutoSupported then \"auto\" else 1024";

     

       20
       20
        
             description = ''

     

       21
       21
       -
               The disk size in megabytes of the virtual machine.

     

       21
       21
       +
               The disk size in MiB (1024×1024 bytes) of the virtual machine.

     

       22
       22
        
             '';

     

       23
       23
        
           };

     

       24
       24
        
         };

+1 -1

nixos/modules/virtualisation/proxmox-image.nix

···

       71
       71
        
               type = types.ints.positive;

     

       72
       72
        
               default = 1024;

     

       73
       73
        
               description = ''

     

       74
       74
       -
                 Guest memory in MB

     

       74
       74
       +
                 Guest memory in MiB (1024×1024 bytes)

     

       75
       75
        
               '';

     

       76
       76
        
             };

     

       77
       77
        
             bios = mkOption {

+3 -3

nixos/modules/virtualisation/qemu-vm.nix

···

       405
       405
        
             type = types.ints.positive;

     

       406
       406
        
             default = 1024;

     

       407
       407
        
             description = ''

     

       408
       408
       -
               The memory size in megabytes of the virtual machine.

     

       408
       408
       +
               The memory size of the virtual machine in MiB (1024×1024 bytes).

     

       409
       409
        
             '';

     

       410
       410
        
           };

     

       411
       411
        
       

     
···

       480
       480
        
             default = [ ];

     

       481
       481
        
             description = ''

     

       482
       482
        
               Additional disk images to provide to the VM. The value is

     

       483
       483
       -
               a list of size in megabytes of each disk. These disks are

     

       483
       483
       +
               a list of size in MiB (1024×1024 bytes) of each disk. These disks are

     

       484
       484
        
               writeable by the VM.

     

       485
       485
        
             '';

     

       486
       486
        
           };

     
···

       1129
       1129
        
               {

     

       1130
       1130
        
                 assertion = pkgs.stdenv.hostPlatform.is32bit -> cfg.memorySize < 2047;

     

       1131
       1131
        
                 message = ''

     

       1132
       1132
       -
                   virtualisation.memorySize is above 2047, but qemu is only able to allocate 2047MB RAM on 32bit max.

     

       1132
       1132
       +
                   virtualisation.memorySize is above 2047, but qemu is only able to allocate 2047 MiB RAM on 32bit max.

     

       1133
       1133
        
                 '';

     

       1134
       1134
        
               }

     

       1135
       1135
        
               {

+1 -1

nixos/modules/virtualisation/waagent.nix

···

       174
       174
        
                 type = types.int;

     

       175
       175
        
                 default = 0;

     

       176
       176
        
                 description = ''

     

       177
       177
       -
                   Specifies the size of the swap file in megabytes.

     

       177
       177
       +
                   Specifies the size of the swap file in MiB (1024×1024 bytes).

     

       178
       178
        
       

     

       179
       179
        
                   This configuration has no effect if resource disk is managed by cloud-init.

     

       180
       180
        
                 '';

+7 -7

pkgs/build-support/vm/default.nix

···

       317
       317
        
         # A bash script fragment that produces a disk image at `destination`.

     

       318
       318
        
         createEmptyImage =

     

       319
       319
        
           {

     

       320
       320
       -
             # Disk image size in MiB

     

       320
       320
       +
             # Disk image size in MiB (1024*1024 bytes)

     

       321
       321
        
             size,

     

       322
       322
        
             # Name that will be written to ${destination}/nix-support/full-name

     

       323
       323
        
             fullName,

     
···

       358
       358
        
           will build the derivation `patchelf' inside a VM.  The attribute

     

       359
       359
        
           `preVM' can optionally contain a shell command to be evaluated

     

       360
       360
        
           *before* the VM is started (i.e., on the host).  The attribute

     

       361
       361
       -
           `memSize' specifies the memory size of the VM in megabytes,

     

       362
       362
       -
           defaulting to 512.  The attribute `diskImage' can optionally

     

       363
       363
       -
           specify a file system image to be attached to /dev/sda.  (Note

     

       364
       364
       -
           that currently we expect the image to contain a filesystem, not a

     

       365
       365
       -
           full disk image with a partition table etc.)

     

       361
       361
       +
           `memSize' specifies the memory size of the VM in MiB (1024*1024

     

       362
       362
       +
           bytes), defaulting to 512.  The attribute `diskImage' can

     

       363
       363
       +
           optionally specify a file system image to be attached to /dev/sda.

     

       364
       364
       +
           (Note that currently we expect the image to contain a filesystem,

     

       365
       365
       +
           not a full disk image with a partition table etc.)

     

       366
       366
        
       

     

       367
       367
        
           If the build fails and Nix is run with the `-K' option, a script

     

       368
       368
        
           `run-vm' will be left behind in the temporary build directory

     
···

       1230
       1230
        
           `extraPackages' specifies the names of additional packages from

     

       1231
       1231
        
           the distribution that should be included in the image; `packages'

     

       1232
       1232
        
           allows the entire set of packages to be overridden; and `size'

     

       1233
       1233
       -
           sets the size of the disk in megabytes.  E.g.,

     

       1233
       1233
       +
           sets the size of the disk in MiB (1024*1024 bytes).  E.g.,

     

       1234
       1234
        
           `diskImageFuns.ubuntu1004x86_64 { extraPackages = ["firefox"];

     

       1235
       1235
        
           size = 8192; }' builds an 8 GiB image containing Firefox in

     

       1236
       1236
        
           addition to the default packages.