Building an Image

After you have set up the manifest file that you plan to use and, if desired, customized the finalizer scripts, you are ready to build an image by running the distro_const command.

Note - You need to run the distro_const command as root user.

You can use the distro_const command to do either of the following:

Build an image in one step.
Build an image, but pause and restart the build as needed to examine the content of the image and debug the finalizer scripts during the build process.

The full syntax for this command is as follows:

Syntax: distro_const build [-R] [-r step] [-p step] [-l] manifest

Building an Image in One Step

To run a complete build of an image without pausing, use the basic distro_const command without options as follows:

# distro_const build manifest

Replace manifest with the name of the manifest file to be used as the blueprint for your image. The build subcommand is required. When you type this command, the distribution constructor pulls the needed packages for the image and builds the image to the specifications that you set up in the manifest file.

Building an Image in Stages

You can use the options provided in the distro_const command to stop and restart the build process at various stages in the image-generation process, in order to check and debug your selection of files, packages, and scripts for the image that is being built. This process of stopping and restarting during the build process is called checkpointing.

Checkpointing supports the process of developing and debugging images. You can start building an image, pause at any stage where you want to stop and examine the contents of the image, then resume building the image. Checkpointing is optional.

Note - The checkpointing feature is enabled by default in the manifest file. But a ZFS dataset, or a mount point that correlates to a ZFS dataset, must be specified as the build area.

Alternately, you can disable checkpointing in the manifest file by setting the checkpoint_enable parameter to false.

Use the checkpointing options that are available in the distro_const command as described in the following basic instructions. See, also, the distro_const(1M) man page.

Building an Image in Stages by Using Checkpoint Options

Before you build the image, check the valid steps at which you can choose to pause or resume the build by using the following command:

# distro_const build -l manifest

Note - The build subcommand is required.

A checkpoint in the build process occurs after each finalizer script is executed.

This command displays the valid checkpoints at which you can pause or resume building an image. Use the step names provided by this command as valid values for the other checkpointing command options.

For example, the following command confirms which checkpoints are available, given a manifest file named slim_cd_x86.xml.

# distro_const build -l slim_cd_x86.xml

After the command is run, the valid checkpointing steps are displayed. Checkpointing steps can include the following.

Step           Resumable Description
-------------- --------- -------------
im-pop             X    Populate the image with packages
im-mod             X    Image area modifications
slim-im-mod             Slim CD image area modifications
ba-init                 Boot archive initialization
slim-ba-config          Slim CD boot archive configuration
ba-config               Boot archive configuration
ba-arch                 Boot archive archiving (64-bit)
ba-arch-32              Boot archive archiving (32-bit)
slim-post-mod           Slim CD post boot archive image area modifications
grub-setup              Grub menu setup
post-mod                Post boot archive image area modification
gen-slim-cont           Generate Slim CD image content list
iso                     ISO image creation 
usb                     USB image creation

Note - In the command output, a check in the resumable field indicates that you can restart the build from this step.

Use the following command to build an image, and to pause building the image at the specified step.
```
# distro_const build -p step manifest
```
Note - The build subcommand is required. The step and manifest fields are required.

For example, the following command starts building an image and pauses the build before step im-mod modifies the image area:
```
# distro_const build -p im-mod slim_cd_x86.xml
```
Resume the build, either from the last step executed or from a specified step, by using one of the following alternatives:
- Use the following command to resume building the image from a specified step.
```
# distro_const build -r step manifest
```
  Note - The specified step must be either the step at which the previous build stopped executing, or an earlier step. A later step is not valid. The step and manifest fields are required. The build subcommand is required.
  
  For example, the following command resumes building the image where the im-mod modifies the image area:
```
# distro_const build -r im-mod slim_cd_x86.xml
```
- Use the following command to resume building the image from the last step executed.
  Note - The manifest argument and the build subcommand are required.
```
# distro_const build -R manifest
```
  For example, the following command resumes building the image from wherever the build had paused.
```
# distro_const build -R slim_cd_x86.xml
```