Provided by: sbuild_0.79.0-1ubuntu1_all 
NAME
sbuild - build debian packages from source
SYNOPSIS
sbuild [-h|--help | -V|--version] [-v|--verbose | -q|--quiet] [-D|--debug] [-A|--arch-all]
[--archive=archive] [-d|--dist=distribution] [-c|--chroot=chroot] [--chroot-
mode=schroot|sudo|autopkgtest|unshare] [--arch=architecture] [--arch-any | --no-arch-any]
[--build=architecture] [--host=architecture] [--profiles=profile[,...]] [-s|--source]
[--force-orig-source] [--make-binNMU=changelog-entry] [--binNMU=NMU-version] [--append-to-version=string]
[--binNMU-timestamp=timestamp] [--binNMU-changelog=changelog] [--build-dir=directory] [--add-
depends=dependency] [--add-conflicts=dependency] [--add-depends-arch=dependency] [--add-
conflicts-arch=dependency] [--add-depends-indep=dependency] [--add-conflicts-indep=dependency]
[-m|--maintainer=maintainer] [-e|--uploader=uploader] [-k|--keyid=key-id] [--source-only-changes]
[--no-source-only-changes] [-j|--jobs=n] [--debbuildopt=option] [--debbuildopts=options] [--dpkg-source-
opt=options] [--dpkg-source-opts=options] [--dpkg-file-suffix=suffix] [-p|--purge=purge-mode]
[--purge-build=purge-mode] [--purge-deps=purge-mode] [--purge-session=purge-mode] [-b|--batch]
[-n|--nolog] [--clean-source] [--no-clean-source] [--run-lintian] [--no-run-lintian]
[--lintian-opt=options] [--lintian-opts=options] [--run-piuparts] [--no-run-piuparts]
[--piuparts-opt=options] [--piuparts-opts=options] [--piuparts-root-arg=options]
[--piuparts-root-args=options] [--run-autopkgtest] [--no-run-autopkgtest] [--autopkgtest-opt=options]
[--autopkgtest-opts=options] [--autopkgtest-root-arg=options] [--autopkgtest-root-args=options]
[--pre-build-commands=string] [--chroot-setup-commands=string] [--chroot-update-failed-commands=string]
[--build-deps-failed-commands=string] [--starting-build-commands=string]
[--finished-build-commands=string] [--build-failed-commands=string] [--chroot-cleanup-commands=string]
[--post-build-commands=string] [--post-build-failed-commands=string] [--anything-failed-commands=string]
[--log-external-command-output] [--log-external-command-error] [--setup-hook=hook-script]
[--build-dep-resolver=resolver] [--resolve-alternatives|--no-resolve-alternatives]
[--extra-package=package.deb] [--extra-repository=spec] [--extra-repository-key=file.asc]
[--build-path=string] [--autopkgtest-virt-server=schroot|lxc|chroot|qemu|ssh]
[--autopkgtest-virt-server-opt=string] [--autopkgtest-virt-server-opts=options] [--purge-extra-packages]
[--bd-uninstallable-explainer=dose3|apt] [PACKAGE[.dsc]]
DESCRIPTION
sbuild rebuilds Debian binary packages from the corresponding Debian source, installing any missing
source dependencies. The build takes place in a dedicated clean build environment, rather than on the
host system. For an overview of the supported chroot backends see the section CHROOT MODES.
sbuild can fetch the Debian source over a network, or it can use locally available sources.
sbuild is given a packages to process as the argument PACKAGE[.dsc]. This argument is in the form of
either a debianized package source directory, a source package name along with a version in the form
package_version, a source package name, or a .dsc file. If no arguments are given, the current working
directory is passed as an argument.
For arguments given as source directories, dpkg-source is first run to produce a source .dsc file. Then,
the package is built using the .dsc produced. For arguments in the form package_version or package, apt
is used to download the source package. For arguments given as a .dsc file, sbuild builds the source
packages directly. For .dsc files in remote locations, the source packages are downloaded first, then
built.
It is also possible to run external commands with sbuild. See the section EXTERNAL COMMANDS for more on
this.
sbuild mails the build logs to a user. It is configured by the configuration files
/etc/sbuild/sbuild.conf and ~/.sbuildrc. An example sbuildrc is available in
/usr/share/doc/sbuild/examples/example.sbuildrc. A custom path to a configuration file can also be
specified through setting the SBUILD_CONFIG environment variable to the path of an additional
configuration file.
You can build either using a local package with its .dsc file or a remote one by specifying an explicit
dpkg version.
OPTIONS
Options set on the command line overwrite settings made in the configuration file.
-h, --help
Display this manual.
-V, --version
Print version information.
--add-depends=dependency
--add-conflicts=dependency
--add-depends-arch=dependency
--add-conflicts-arch=dependency
--add-depends-indep=dependency
--add-conflicts-indep=dependency
These options add a build dependencies to the source package being built, in addition to the build
dependency information specified in debian/control. These dependencies will be concatenated
directly to the Build-Depends, Build-Conflicts, Build-Depends-Arch, Build-Conflicts-Arch, Build-
Depends-Indep and Build-Conflicts-Indep dependencies, respectively. The options may be used any
number of times to add multiple dependencies. The format is identical to the format used in
debian/control. These command line options append to the MANUAL_DEPENDS, MANUAL_CONFLICTS,
MANUAL_DEPENDS_ARCH, MANUAL_CONFLICTS_ARCH, MANUAL_DEPENDS_INDEP and MANUAL_CONFLICTS_INDEP
configuration variables, respectively. See sbuild.conf(5) for more information.
--arch=architecture
Build using the architecture specified. A chroot named $distribution-$arch-sbuild or
$distribution-arch is searched for, in that order of preference. The chroot must be installed and
configured appropriately to build as that architecture, e.g. using personality=linux32 to build
i386 packages on an amd64 system. Note that this option is equivalent to "--host=architecture
--build=architecture". This command line option sets the HOST_ARCH and BUILD_ARCH configuration
variables. See sbuild.conf(5) for more information.
--host=architecture
Build using the host architecture specified. If $host and $build don't match, a chroot named
$distribution-$build-$host-sbuild or $distribution-$build-$host is searched for, falling back to
$distribution-$build-sbuild or $distribution-$build, in that order of preference. This option is
only useful for cross-building when used together with --build. This command line option sets the
HOST_ARCH configuration variable. See sbuild.conf(5) for more information.
--build=architecture
Build using the build architecture specified. This option is only useful for cross-building when
used together with --host. If --build is not specified, the default system architecture is
assumed. This command line option sets the BUILD_ARCH configuration variable. See sbuild.conf(5)
for more information.
-A, --arch-all
Also build Architecture: all packages. This option is the opposite of --no-arch-all. See the
section BUILD ARTIFACTS for more information. This command line option sets the BUILD_ARCH_ALL
configuration variable. See sbuild.conf(5) for more information.
--no-arch-all
Do not build Architecture: all packages. This is the default behaviour. This option is the
opposite of --arch-all. See the section BUILD ARTIFACTS for more information. This command line
option sets the BUILD_ARCH_ALL configuration variable. See sbuild.conf(5) for more information.
--arch-any
Build Architecture: any packages. This is the default behavior. This option is the opposite of
--no-arch-any. See the section BUILD ARTIFACTS for more information. This command line option
sets the BUILD_ARCH_ANY configuration variable. See sbuild.conf(5) for more information.
--no-arch-any
Do not build Architecture: any packages. This option is the opposite of --arch-any and only useful
when used together with --arch-all or --source. See the section BUILD ARTIFACTS for more
information. This command line option sets the BUILD_ARCH_ANY configuration variable. See
sbuild.conf(5) for more information.
-b, --batch
Operate in batchmode, i.e. write a build-progress file during execution and files on shutdown to
facilitate a clean restart. This command line option sets the BATCH_MODE configuration variable.
See sbuild.conf(5) for more information.
-c, --chroot=chroot
Specifies the chroot to use. The effect of this option depends on the selected chroot mode. With
the schroot chroot mode, this option specifies the schroot name or alias to use. If not specified,
the default is the first of schroot name or alias that matches $distribution-$arch-sbuild,
$distribution-sbuild, $distribution-$arch or $distribution that exists. With the sudo chroot
mode, this option specifies the chroot directory to use. The directory is either expected in
/etc/sbuild/chroot (in buildd sbuild mode) or in the build directory (see --build-dir), prefixed
with "chroot-" (in user sbuild mode, the default). If not specified, the default is to search for
a directory in the respective locations named in the same way as for the schroot mode. With the
unshare chroot mode, if this option is a path, then it specifies the location of the chroot
tarball directly. Otherwise, a tarball with equal basename from ~/.cache/sbuild will be used. If
not specified, the default is to search for a tarball named in the same way as for the schroot
mode under ~/.cache/sbuild. With the autopkgtest chroot mode this option has no effect. The
--autopkgtest-virt-server-opts are used to pick the chroot in autopkgtest chroot mode. This
command line option sets the CHROOT configuration variable. See sbuild.conf(5) for more
information.
--chroot-mode=schroot|sudo|autopkgtest|unshare
Select the desired chroot mode. Four values are possible: schroot (the default), sudo (which uses
sudo to execute chroot in a directory from /etc/sbuild/chroot or ./chroot), autopkgtest which uses
the autopkgtest-virt-* binaries (selectable via the --autopkgtest-virt-server option) and unshare
(which uses linux namespaces for chroot and doesn't require superuser privileges). See the
section CHROOT MODES for more information. This command line option sets the CHROOT_MODE
configuration variable. See sbuild.conf(5) for more information.
-d, --dist=distribution
Explicitly set the distribution for the package build. This will be selecting the correct chroot
to use and also sets the value of the Distribution field in the created .changes file. Setting
this option is necessary when giving sbuild a .dsc file or a plain source package name to build.
In the latter case it specifies the distribution the source package is fetched from. This command
line option sets the DISTRIBUTION configuration variable. See sbuild.conf(5) for more information.
--archive=archive
Communicate with specified archive. This command line option sets the ARCHIVE configuration
variable. See sbuild.conf(5) for more information.
-D, --debug
Enable debug output.
--apt-clean
--no-apt-clean
Run (or do not run) apt-get clean in the chroot before executing the build, overriding the default
setting. This command line option sets the APT_CLEAN configuration variable. See sbuild.conf(5)
for more information.
--apt-update
--no-apt-update
Run (or do not run) apt-get update in the chroot before executing the build, overriding the
default setting. This option has no effect on updating the internal sbuild apt repository, the
repository for extra packages (see --extra-package) and the repositories given via --extra-
repository. These are always updated. Thus, this option only influences updates of the default
repositories of the chroot. This command line option sets the APT_UPDATE configuration variable.
See sbuild.conf(5) for more information.
--apt-upgrade
--no-apt-upgrade
Run (or do not run) apt-get upgrade in the chroot before executing the build, overriding the
default setting. This command line option sets the APT_UPGRADE configuration variable. See
sbuild.conf(5) for more information.
--apt-distupgrade
--no-apt-distupgrade
Run (or do not run) apt-get distupgrade in the chroot before executing the build, overriding the
default setting. This command line option sets the APT_DISTUPGRADE configuration variable. See
sbuild.conf(5) for more information.
-m, --maintainer=maintainer
Specify the identity to use for GPG signing packages, and also used as the maintainer for binary
NMUs. This does not normally require setting (it defaults to the uploader). This command line
option sets the MAINTAINER_NAME configuration variable. See sbuild.conf(5) for more information.
-e, --uploader=uploader
Passed to dpkg-genchanges and is used to set the Changed-by: field in the .changes file(s). This
command line option sets the UPLOADER_NAME configuration variable. See sbuild.conf(5) for more
information.
-k, --keyid=key-id
Passed to debsign and is used to set the key to sign the .changes file(s). Default is not using
any key and not signing the .changes file(s). This command line option sets the KEY_ID
configuration variable. See sbuild.conf(5) for more information.
--source-only-changes
--no-source-only-changes
In addition to the .changes file generated by dpkg-buildpackage, also produce (or don't produce) a
.changes file suitable for a source-only upload. If requested by --keyid, this .changes file will
also be signed by debsign. This command line option sets the SOURCE_ONLY_CHANGES configuration
variable. See sbuild.conf(5) for more information.
-j, --jobs=n
Number of jobs to run simultaneously. Passed through to dpkg-buildpackage. This command line
option appends the appropriate -j option to the DPKG_BUILDPACKAGE_USER_OPTIONS configuration
variable. See sbuild.conf(5) for more information.
--debbuildopt=option
Pass the specified option directly to dpkg-buildpackage in addition to the options already passed
by sbuild. This option can be passed multiple times (once per dpkg-buildpackage option) and can be
freely mixed with the --debbuildopts option. Options will be passed to dpkg-buildpackage in the
order that the --debbuildopt and --debbuildopts options are given on the command line. This
command line option appends to the DPKG_BUILDPACKAGE_USER_OPTIONS configuration variable. See
sbuild.conf(5) for more information.
--debbuildopts=options
Pass the specified options directly to dpkg-buildpackage in addition to the options already passed
by sbuild. The argument will be split by whitespaces and the resulting array passed to the
dpkg-buildpackage invocation. If any options contain spaces, use --debbuildopt for them. This
option can be passed multiple times and can be freely mixed with the --debbuildopt option. Options
will be passed to dpkg-buildpackage in the order that the --debbuildopt and --debbuildopts options
are given on the command line. This command line option appends to the
DPKG_BUILDPACKAGE_USER_OPTIONS configuration variable. See sbuild.conf(5) for more information.
--dpkg-source-opt=options
Pass the specified option directly to dpkg-source in addition to the options already passed by
sbuild. This is only used when creating a source package from a Debianized source directory. This
option can be passed multiple times (once per dpkg-source option) and can be freely mixed with the
--dpkg-source-opts option. Options will be passed to dpkg-source in the order that the
--dpkg-source-opt and --dpkg-source-opts options are given on the command line. This command line
option appends to the DPKG_SOURCE_OPTIONS configuration variable. See sbuild.conf(5) for more
information.
NOTE: The '-b', '--before-build' and '--after-build' options will always be passed to dpkg-source,
respectively.
--dpkg-source-opts=options
Pass the specified options directly to dpkg-source in addition to the options already passed by
sbuild. The argument will be split by whitespaces and the resulting array passed to the
dpkg-source invocation. This is only used when creating a source package from a Debianized source
directory. If any options contain spaces, use --dpkg-source-opt for them. This option can be
passed multiple times and can be freely mixed with the --dpkg-source-opt option. Options will be
passed to dpkg-source in the order that the --dpkg-source-opt and --dpkg-source-opts options are
given on the command line. This command line option appends to the DPKG_SOURCE_OPTIONS
configuration variable. See sbuild.conf(5) for more information.
NOTE: The '-b', '--before-build' and '--after-build' options will always be passed to dpkg-source,
respectively.
--dpkg-file-suffix=suffix
Add the suffix to the filename of the changes and buildinfo files generated by dpkg.
NOTE: This option is ignored if dpkg-dev in the build environment is too old to support it. At
least dpkg-dev 1.18.11 is required.
--mail-log-to=email-address
Send the build log to the specified email address. This command line option sets the MAILTO
configuration variable. See sbuild.conf(5) for more information.
--mailfrom=email-address
Email address used as the sender address for build logs. This command line option sets the
MAILFROM configuration variable. See sbuild.conf(5) for more information.
-n, --nolog
Do not create a package log file in the $log_dir directory and no build log file, but print
everything to stdout. Also do not send any log mails. This command line option sets the NOLOG
configuration variable. See sbuild.conf(5) for more information.
--profiles=profile[,...]"
Specify the profile(s) we build, as a comma-separated list. Defaults to the space separated list
of profiles in the DEB_BUILD_PROFILES environment variable when building natively or the cross and
nocheck profiles when cross-building. This command line option sets the BUILD_PROFILES
configuration variable. See sbuild.conf(5) for more information.
-p, --purge=purge-mode
Convenience option to set purge-mode for build directory, build dependencies and session. This
command line option sets the PURGE_BUILD_DEPS, PURGE_BUILD_DIRECTORY and PURGE_SESSION
configuration variables. See sbuild.conf(5) for more information.
--purge-build=purge-mode
purge-mode determines if the build directory will be deleted after a build. Possible values are
always (default), never, and successful. This command line option sets the PURGE_BUILD_DIRECTORY
configuration variable. See sbuild.conf(5) for more information.
--purge-deps=purge-mode
purge-mode determines if the build dependencies will be removed after a build. Possible values are
always (default), never, and successful. This command line option sets the PURGE_BUILD_DEPS
configuration variable. See sbuild.conf(5) for more information.
--purge-session=purge-mode
Purge the schroot session following a build. This is useful in conjunction with the --purge-build
and --purge-deps options when using snapshot chroots, since by default the snapshot will be
deleted. Possible values are always (default), never, and successful. This command line option
sets the PURGE_SESSION configuration variable. See sbuild.conf(5) for more information.
-s, --source
Build the source package in addition to the other requested build artifacts. By default, the dsc
will not be rewritten because the source package is the input to sbuild, not its output. Even when
running from an unpacked source tree sbuild will first build the source package using dpkg-source
and then pass that on to the sbuild machinery. Use this option only when you know what you are
doing. This will rewrite the original dsc passed to sbuild. See the section BUILD ARTIFACTS for
more information. This command line option sets the BUILD_SOURCE configuration variable. See
sbuild.conf(5) for more information.
--no-source
Don't rebuild the source package. This is the default. It is the opposite of --source. See the
section BUILD ARTIFACTS for more information. This command line option sets the BUILD_SOURCE
configuration variable. See sbuild.conf(5) for more information.
--force-orig-source
When used with in conjunction with -s, this option forces the inclusion of the orig.tar.gz file in
the generated .changes file, even in cases where it would not normally be included, i.e. use
dpkg-buildpackage -sa. This command line option sets the FORCE_ORIG_SOURCE configuration
variable. See sbuild.conf(5) for more information.
--use-snapshot
Installs the latest snapshot gcc compiler from the gcc-snapshot package, and alters the build
environment to use the snapshot compiler for the build. Specifically, this option appends
/usr/lib/gcc-snapshot/lib to the value of the LD_LIBRARY_PATH configuration variable and
/usr/lib/gcc-snapshot/bin to the value of the PATH configuration variable. It also sets the
GCC_SNAPSHOT configuration variable. See sbuild.conf(5) for more information.
-v, --verbose
Be verbose, i.e. all information goes to stdout as well as to the log files.
-q, --quiet
Be quiet. This is the opposite of --verbose.
--make-binNMU=changelog-entry
With this option, sbuild will create a new changelog entry in debian/changelog of every package
built. The version number will be in the format for binary-only NMUs (see --binNMU); the
maintainer is set to the maintainer name configured for sbuild. changelog-entry will be used as
the changelog entry following “Binary-only non-maintainer upload for ARCH -- no source changes”.
Please note that the versions in the PACKAGE_VERSION[.dsc] arguments still have to be the
unmodified (non-NMU ones) so that the sources can be found. The version number in log files and
mails will be modified by sbuild automatically. The --append-to-version option has a similar
effect but allows one to specify an arbitrary version suffix instead of a custom changelog entry.
To have a custom version suffix and a custom changelog entry, use --make-binNMU and
--append-to-version at the same time with --binNMU=0. This option is incompatible with
--binNMU-changelog. This option implies --no-arch-all. This command line option sets the BIN_NMU
configuration variable and sets the BIN_NMU_VERSION configuration variable to 1 if it was not set
yet, for example by the --binNMU option. See sbuild.conf(5) for more information.
--binNMU=NMU-version
The version number of the binary NMU. This option only has an effect if combined with
--make-binNMU and/or with --append-to-version. version is a single number for the (+bn) format
used for binary NMUs. If the argument is the empty string or zero, then the +bn suffix will not
be appended. The +bn suffix will be appended after the string given via --append-to-version.
This option is incompatible with --binNMU-changelog. This command line option sets the
BIN_NMU_VERSION configuration variable. See sbuild.conf(5) for more information.
--append-to-version=string
This option is similar to --make-binNMU except that it allows the user to specify an arbitrary
string to be appended to the version number (immediately before the '+' in the Debian revision if
--make-binNMU is also provided). To pass an arbitrary changelog text as well, combine this option
with --make-binNMU but be aware that this will also add the +bn suffix unless you also pass
--binNMU=0 to disable it. This option is incompatible with --binNMU-changelog. This option
implies --no-arch-all. This command line option sets the APPEND_TO_VERSION configuration
variable. See sbuild.conf(5) for more information.
--binNMU-timestamp=timestamp
Set the timestamp of the new binNMU changelog entry. By default, the time of the build will be
used to generate the binNMU changelog timestamp. This option allows one to use a custom timestamp
instead. The timestamp is either given as an integer in Unix time or as a string in the format
compatible with Debian changelog entries (i.e. as it is generated by date -R). This option is
incompatible with --binNMU-changelog. This command line option sets the BIN_NMU_TIMESTAMP
configuration variable. See sbuild.conf(5) for more information.
--binNMU-changelog=changelog
Set the complete content of a binary-only changelog entry. This option allows full customization
of the new changelog entry. It is up to the user to make sure that the changelog entry is well-
formed. The argument has to include all necessary newlines. Leading and trailing newlines will be
stripped. Sbuild will not interpret any backslash escapes. This option is incompatible with
--make-binNMU, --binNMU, --append-to-version and --binNMU-timestamp. This command line option
sets the BIN_NMU_CHANGELOG configuration variable. See sbuild.conf(5) for more information.
--build-dir=directory
Set the output directory for the build artifacts created by dpkg-buildpackage and the log file. By
default, the current directory is used or, when sbuild is executed from within an unpacked source
directory, the parent directory. This command line option sets the BUILD_DIR configuration
variable. See sbuild.conf(5) for more information.
--clean-source
When executing sbuild from within an unpacked source tree, execute the debian/rules clean target.
This is the default and might require some of the build dependencies installed on the host. This
command line option sets the CLEAN_SOURCE configuration variable. See sbuild.conf(5) for more
information.
--no-clean-source
When executing sbuild from within an unpacked source tree, do not run the debian/rules clean
target before building the source package. Only set this if you start from a clean checkout and
you know what you are doing. This command line option sets the CLEAN_SOURCE configuration
variable. See sbuild.conf(5) for more information.
--run-lintian
Run lintian after a successful build. This command line option sets the RUN_LINTIAN configuration
variable. See sbuild.conf(5) for more information.
--no-run-lintian
Don't run lintian after a successful build. If sbuild is configured to run lintian by default,
this option will prevent lintian being run. This command line option sets the RUN_LINTIAN
configuration variable. See sbuild.conf(5) for more information.
--lintian-opt=options
Pass the specified option directly to lintian in addition to the options already passed by sbuild.
This option can be passed multiple times (once per lintian option) and can be freely mixed with
the --lintian-opts option. Options will be passed to lintian in the order that the --lintian-opt
and --lintian-opts options are given on the command line. This command line option appends to the
LINTIAN_OPTIONS configuration variable. See sbuild.conf(5) for more information.
--lintian-opts=options
Pass the specified options directly to lintian in addition to the options already passed by
sbuild. The argument will be split by whitespaces and the resulting array passed to the lintian
invocation. If any options contain spaces, use --lintian-opt for them. This option can be passed
multiple times and can be freely mixed with the --lintian-opts option. Options will be passed to
lintian in the order that the --lintian-opt and --lintian-opts options are given on the command
line. This command line option appends to the LINTIAN_OPTIONS configuration variable. See
sbuild.conf(5) for more information.
--run-piuparts
Run piuparts after a successful build. This command line option sets the RUN_PIUPARTS
configuration variable. See sbuild.conf(5) for more information.
--no-run-piuparts
Don't run piuparts after a successful build. If sbuild is configured to run piuparts by default,
this option will prevent piuparts being run. This command line option sets the RUN_PIUPARTS
configuration variable. See sbuild.conf(5) for more information.
--piuparts-opt=options
Pass the specified option directly to piuparts in addition to the options already passed by
sbuild. This option can be passed multiple times (once per piuparts option) and can be freely
mixed with the --piuparts-opts option. Options will be passed to piuparts in the order that the
--piuparts-opt and --piuparts-opts options are given on the command line. Certain percent escapes
are supported. To write a literal percent sign, escape it with another percent sign. See the
section OPTION STRING PERCENT ESCAPES for more information. This command line option appends to
the PIUPARTS_OPTIONS configuration variable. See sbuild.conf(5) for more information.
--piuparts-opts=options
Pass the specified options directly to piuparts in addition to the options already passed by
sbuild. The argument will be split by whitespaces and the resulting array passed to the piuparts
invocation. If any options contain spaces, use --piuparts-opt for them. This option can be passed
multiple times and can be freely mixed with the --piuparts-opts option. Options will be passed to
piuparts in the order that the --piuparts-opt and --piuparts-opts options are given on the command
line. Certain percent escapes are supported. To write a literal percent sign, escape it with
another percent sign. See the section OPTION STRING PERCENT ESCAPES for more information. This
command line option appends to the PIUPARTS_OPTIONS configuration variable. See sbuild.conf(5) for
more information.
--piuparts-root-arg=options
Add an argument that is used to launch piuparts as root. Without this option, the default is to
use "sudo --" to launch piuparts. If an empty string is supplied, then piuparts is launched
without any prefixed command. This option can be specified multiple times. This command line
option appends to the PIUPARTS_ROOT_ARGS configuration variable. See sbuild.conf(5) for more
information.
--piuparts-root-args=options
Add arguments that are used to launch piuparts as root. Without this option, the default is to
use "sudo --" to launch piuparts. If an empty string is supplied, then piuparts is launched
without any prefixed command. The argument will be split by whitespaces. To pass options
containing whitespaces use the option --piuparts-root-arg. This command line option appends to
the PIUPARTS_ROOT_ARGS configuration variable. See sbuild.conf(5) for more information.
--run-autopkgtest
Run autopkgtest after a successful build. This command line option sets the RUN_AUTOPKGTEST
configuration variable. See sbuild.conf(5) for more information.
--no-run-autopkgtest
Don't run autopkgtest after a successful build. If sbuild is configured to run autopkgtest by
default, this option will prevent autopkgtest being run. This command line option sets the
RUN_AUTOPKGTEST configuration variable. See sbuild.conf(5) for more information.
--autopkgtest-opt=options
Pass the specified option directly to autopkgtest in addition to the options already passed by
sbuild. This option can be passed multiple times (once per autopkgtest option) and can be freely
mixed with the --autopkgtest-opts option. Options will be passed to autopkgtest in the order that
the --autopkgtest-opt and --autopkgtest-opts options are given on the command line. Certain
percent escapes are supported. To write a literal percent sign, escape it with another percent
sign. See the section OPTION STRING PERCENT ESCAPES for more information. This command line
option appends to the AUTOPKGTEST_OPTIONS configuration variable. See sbuild.conf(5) for more
information.
--autopkgtest-opts=options
Pass the specified options directly to autopkgtest in addition to the options already passed by
sbuild. The argument will be split by whitespaces and the resulting array passed to the
autopkgtest invocation. If any options contain spaces, use --autopkgtest-opt for them. This
option can be passed multiple times and can be freely mixed with the --autopkgtest-opts option.
Options will be passed to autopkgtest in the order that the --autopkgtest-opt and
--autopkgtest-opts options are given on the command line. Certain percent escapes are supported.
To write a literal percent sign, escape it with another percent sign. See the section OPTION
STRING PERCENT ESCAPES for more information. This command line option appends to the
AUTOPKGTEST_OPTIONS configuration variable. See sbuild.conf(5) for more information.
--autopkgtest-root-arg=options
Add an argument that is used to launch autopkgtest as root. Without this option, the default is to
use "sudo --" to launch autopkgtest. If an empty string is supplied, then autopkgtest is launched
without any prefixed command. This option can be specified multiple times. This command line
option appends to the AUTOPKGTEST_ROOT_ARGS configuration variable. See sbuild.conf(5) for more
information.
--autopkgtest-root-args=options
Add arguments that are used to launch autopkgtest as root. Without this option, the default is to
use "sudo --" to launch autopkgtest. If an empty string is supplied, then autopkgtest is launched
without any prefixed command. The argument will be split by whitespaces. To pass options
containing whitespaces use the option --autopkgtest-root-arg. This command line option appends to
the AUTOPKGTEST_ROOT_ARGS configuration variable. See sbuild.conf(5) for more information.
--pre-build-commands=string
This is the earliest external command which is run right after the chroot session has been
initialized and before anything else is done (like installing the build dependencies). The command
is run outside of the chroot. This option can be used multiple times to add multiple commands.
Certain percent escapes are supported. To write a literal percent sign, escape it with another
percent sign. See the section EXTERNAL COMMANDS for more information. This command line option
appends to the EXTERNAL_COMMANDS configuration variable. See sbuild.conf(5) for more information.
--chroot-setup-commands=string
Run these commands after the chroot and variables have been setup but before dependencies are
installed. The command is run as root inside of the chroot. This option can be used multiple
times to add multiple commands. Certain percent escapes are supported. To write a literal percent
sign, escape it with another percent sign. See the section EXTERNAL COMMANDS for more information.
This command line option appends to the EXTERNAL_COMMANDS configuration variable. See
sbuild.conf(5) for more information.
--chroot-update-failed-commands=string
Run these commands after any of 'apt-get update', 'apt-get upgrade' or 'apt-get dist-upgrade'
failed. This hook is not run for updates of the internal sbuild apt repository, the repository
for extra packages (see --extra-package) and the repositories given via --extra-repository. The
environment is intact, and the failure can be investigated. Especially %SBUILD_SHELL is useful
here. This option can be used multiple times to add multiple commands. Certain percent escapes are
supported. To write a literal percent sign, escape it with another percent sign.See the section
EXTERNAL COMMANDS for more information. This command line option appends to the EXTERNAL_COMMANDS
configuration variable. See sbuild.conf(5) for more information.
--build-deps-failed-commands=string
These commands are run if installing the build dependencies has failed directly after the failed
attempt. The environment is intact, and the failure can be investigated. Especially %SBUILD_SHELL
is useful here. The command is run as root inside the chroot. This option can be used multiple
times to add multiple commands. Certain percent escapes are supported. To write a literal percent
sign, escape it with another percent sign. See the section EXTERNAL COMMANDS for more information.
This command line option appends to the EXTERNAL_COMMANDS configuration variable. See
sbuild.conf(5) for more information.
--starting-build-commands=string
Run these commands after dependencies are installed, just before the package build with dpkg-
buildpackage starts. The command is run as the (non-root) user running sbuild inside the chroot.
This option can be used multiple times to add multiple commands. Certain percent escapes are
supported. To write a literal percent sign, escape it with another percent sign. See the section
EXTERNAL COMMANDS for more information. This command line option appends to the EXTERNAL_COMMANDS
configuration variable. See sbuild.conf(5) for more information.
--finished-build-commands=string
Run these commands immediately after the timed package build finishes. The command is run as the
(non-root) user running sbuild inside the chroot. This option can be used multiple times to add
multiple commands. Certain percent escapes are supported. To write a literal percent sign, escape
it with another percent sign. See the section EXTERNAL COMMANDS for more information. This
command line option appends to the EXTERNAL_COMMANDS configuration variable. See sbuild.conf(5)
for more information.
--build-failed-commands=string
These commands are run if dpkg-buildpackage has failed directly after the failed attempt. The
environment is intact, and the failure can be investigated. Especially %SBUILD_SHELL is useful
here. The command is run as the (non-root) user running %sbuild inside the chroot. This option can
be used multiple times to add multiple commands. Certain percent escapes are supported. To write a
literal percent sign, escape it with another percent sign. See the section EXTERNAL COMMANDS for
more information. This command line option appends to the EXTERNAL_COMMANDS configuration
variable. See sbuild.conf(5) for more information.
--chroot-cleanup-commands=string
Run these commands when a chroot is cleaned up, before build directory is purged. The command is
run as root inside the chroot. This option can be used multiple times to add multiple commands.
Certain percent escapes are supported. To write a literal percent sign, escape it with another
percent sign. See the section EXTERNAL COMMANDS for more information. This command line option
appends to the EXTERNAL_COMMANDS configuration variable. See sbuild.conf(5) for more information.
--post-build-commands=string
Run this command after a successful build. The command is run outside of the chroot. This option
can be used multiple times to add multiple commands. Certain percent escapes are supported. To
write a literal percent sign, escape it with another percent sign. See the section
--post-build-failed-commands=string
Exactly like the above, but when a build fails. EXTERNAL COMMANDS for more information. This
command line option appends to the EXTERNAL_COMMANDS configuration variable. See sbuild.conf(5)
for more information.
--anything-failed-commands=string
Run these commands for all the --xxx-failed-commands options. Especially %SBUILD_SHELL is useful
here. This option can be used multiple times to add multiple commands. Certain percent escapes are
supported. To write a literal percent sign, escape it with another percent sign. See the section
EXTERNAL COMMANDS for more information. This command line option appends to the EXTERNAL_COMMANDS
configuration variable. See sbuild.conf(5) for more information.
--log-external-command-output
Write output from external commands to the build log. This command line option sets the
LOG_EXTERNAL_COMMAND_OUTPUT configuration variable. See sbuild.conf(5) for more information.
--log-external-command-error
Write error output from external commands to the build log. This command line option sets the
LOG_EXTERNAL_COMMAND_ERROR configuration variable. See sbuild.conf(5) for more information.
--setup-hook=hook-script DEPRECATED
This option is deprecated. Use of this option will add hook-script to the external commands to run
via chroot-setup-commands. This command line option sets the CHROOT_SETUP_SCRIPT configuration
variable and appends to the EXTERNAL_COMMANDS configuration variable. See sbuild.conf(5) for more
information.
--build-dep-resolver=resolver
Use the specified resolver to handle selecting the build dependencies. Supported resolvers are
apt (the default), aptitude, aspcud, xapt, and null. The apt resolver is the most appropriate
resolver for most users, for building for unstable, stable and other distributions. If
alternative build dependencies are used (excluding architecture restrictions), only the first
alternative will be used; the others will be ignored. The aptitude resolver is very similar, but
smarter and slower, and it will consider all alternatives by default; it is suited to more complex
situations, such as building packages for the experimental distribution, where packages need
installing from multiple suites (unstable and experimental). Due to performance and other issues
(bug #139615), aptitude is not recommended for use by default. If the dependency situation is so
complex that neither apt nor aptitude are able to find a solution, then you can use the aspcud
resolver. This resolver uses apt-cudf to ask aspcud, a real solver (in the math sense), to find a
solution to the installation problem. Since aspcud uses a real solver (an ASP solver) it will
always find a solution if one exists. The solution found by the aspcud resolver can be refined by
changing the default optimization criteria through the --aspcud-criteria option. The xapt
resolver is intended only for cross-building, and is a temporary transitional feature which will
be removed following the complete introduction of multi-arch support. Finally, the null resolver
is a dummy solver which does not install, upgrade or remove any packages. This allows one to
completely control package installation via hooks. This command line option sets the
BUILD_DEP_RESOLVER configuration variable. See sbuild.conf(5) for more information.
--aspcud-criteria=criteria
Optimization criteria in extended MISC 2012 syntax passed to aspcud through apt-cudf.
Optimization criteria are separated by commas, sorted by decreasing order of priority and are
prefixed with a polarity (+ to maximize and - to minimize). The default criteria is
-removed,-changed,-new which first minimizes the number of removed packages, then the number of
changed packages (up or downgrades) and then the number of new packages. A common task is to
minimize the number of packages from experimental. To do this you can add a criteria like
-count(solution,APT-Release:=/a=experimental/) to the default criteria. This will then minimize
the number of packages in the solution which contain the string a=experimental in the APT-Release
field of the EDSP output created by apt. For more help on how to write optimization criteria, see
the apt-cudf(1) man page. Specifically the help on the --criteria option. This command line
option sets the ASPCUD_CRITERIA configuration variable. See sbuild.conf(5) for more information.
--resolve-alternatives
Allow the use of alternatives in Build-Depends, Build-Depends-Arch and Build-Depends-Indep. This
is the default for the aptitude dependency resolver. This command line option sets the
RESOLVE_ALTERNATIVES configuration variable. See sbuild.conf(5) for more information.
--no-resolve-alternatives
Do not allow the use of alternatives in Build-Depends, Build-Depends-Arch and Build-Depends-Indep.
Note that alternatives for the same package (e.g. different versions) are still allowed. This is
the default for the apt and xapt dependency resolvers. This command line option sets the
RESOLVE_ALTERNATIVES configuration variable. See sbuild.conf(5) for more information.
--extra-package=package.deb|directory
Make package.deb available for build-dependency resolution, by adding it to a temporary archive
created by sbuild. This makes it easier to build packages against locally-built build
dependencies, without waiting for those packages to enter the main archive, or going through the
hassle of maintaining a local archive and making it accessible inside the chroot. package.deb is
copied into the chroot, so it can refer to any path on the host system. If a directory is passed
instead of a regular file, then all regular files inside that directory with a filename that ends
in .deb will be added in the same fashion as it is done for individual packages. This option can
be specified multiple times. This command line option appends to the EXTRA_PACKAGES configuration
variable. See sbuild.conf(5) for more information.
--extra-repository=spec
Add a repository to the list of apt sources during the package build. The repository
specification is a line suitable for an apt sources.list(5) file. For instance, you might use
--extra-repository="deb http://deb.debian.org/debian experimental main" to allow packages in the
experimental distribution to fulfill build-dependencies. Note that the build chroot must already
trust the key of this repository or a key must be given with the --extra-repository-key flag (see
apt-secure(8)). This command line option appends to the EXTRA_REPOSITORIES configuration
variable. See sbuild.conf(5) for more information.
--extra-repository-key=file.asc
Add file.asc to the list of trusted keys inside the chroot. The key is read from the filename
given, and added to the trusted keys. For more information, see apt-secure(8). This flag is
particularly useful if the target in --extra-repository is not signed with a key that's trusted by
the base chroot. This command line option appends to the EXTRA_REPOSITORY_KEYS configuration
variable. See sbuild.conf(5) for more information.
--build-path=string
By default the package is built in a path of the following format /build/packagename-
XXXXXX/packagename-version/ where XXXXXX is a random ascii string. This option allows one to
specify a custom path where the package is built inside the chroot. The sbuild user in the chroot
must have permissions to create the path. Common writable locations are subdirectories of /tmp or
/build. Using /tmp might be dangerous, because (depending on the chroot mode) the /tmp inside the
chroot might be a world writable location that can be accessed by processes outside the chroot.
The directory /build can only be accessed by the sbuild user and group and should be a safe
location. The buildpath must be an empty directory because the last component of the path will be
removed after the build is finished. Notice that depending on the chroot mode (see --chroot-
mode), some locations inside the chroot might be bind mounts that are shared with other sbuild
instances. You must avoid using these shared locations as the build path or otherwise concurrent
runs of sbuild will likely fail. With the default schroot chroot mode, the directory /build is
shared between multiple schroot sessions. You can change this behaviour in
/etc/schroot/sbuild/fstab. The behaviour of other chroot modes will vary. This command line
option sets the BUILD_PATH configuration variable. See sbuild.conf(5) for more information.
--autopkgtest-virt-server=schroot|lxc|chroot|qemu|ssh
The autopkgtest virtualization server. Can be specified with or without the autopkgtest-virt-
prefix. For instance, the following set of command line options will use the autopkgtest-virt-
schroot chroot mode for a package build: --chroot-mode=autopkgtest
--autopkgtest-virt-server=schroot --chroot unstable-amd64-sbuild The value of the --chroot option
will be passed as the last positional argument to the autopkgtest-virt-* invocation. Thus, the
value of the --chroot option becomes the image name of the virtual machine in case of autopkgtest-
virt-qemu, the lxc-container name in case of autopkgtest-virt-lxc, the path to the chroot in case
of autopkgtest-virt-chroot, the name of the schroot in case of autopkgtest-virt-schroot and so on.
This command line option sets the AUTOPKGTEST_VIRT_SERVER configuration variable. See
sbuild.conf(5) for more information.
--autopkgtest-virt-server-opt=string
Pass the specified option directly to the respective autopkgtest-virt-* virtualization server in
addition to the options already passed by sbuild. This option can be passed multiple times (once
per autopkgtest-virt-* option) and can be freely mixed with the --autopkgtest-virt-server-opts
option. Options will be passed to the respective autopkgtest-virt-* virtualization server in the
order that the --autopkgtest-virt-server-opt and --autopkgtest-virt-server-opts options are given
on the command line. See the manual pages of the respective autopkgtest-virt-* commands for more
information. Certain percent escapes are supported. To write a literal percent sign, escape it
with another percent sign. See the section OPTION STRING PERCENT ESCAPES for more information.
This command line option appends to the AUTOPKGTEST_VIRT_SERVER_OPTIONS configuration variable.
See sbuild.conf(5) for more information.
--autopkgtest-virt-server-opts=options
Pass the specified options directly to the respective autopkgtest-virt-* virtualization server in
addition to the options already passed by sbuild. The argument will be split by whitespaces and
the resulting array passed to the autopkgtest-virt-* invocation. If any options contain spaces,
use --autopkgtest-virt-server-opt for them. This option can be passed multiple times and can be
freely mixed with the --autopkgtest-virt-server-opts option. Options will be passed to the
respective autopkgtest-virt-* virtualization server in the order that the
--autopkgtest-virt-server-opt and --autopkgtest-virt-server-opts options are given on the command
line. See the manual pages of the respective autopkgtest-virt-* commands for more information.
Certain percent escapes are supported. To write a literal percent sign, escape it with another
percent sign. See the section OPTION STRING PERCENT ESCAPES for more information. This command
line option appends to the AUTOPKGTEST_VIRT_SERVER_OPTIONS configuration variable. See
sbuild.conf(5) for more information.
--sbuild-mode=mode
Behaviour changes for use in a buildd environment. This command line option sets the SBUILD_MODE
configuration variable. See sbuild.conf(5) for more information.
--stats-dir=directory
Directory for writing build statistics to. This command line option sets the STATS_DIR
configuration variable. See sbuild.conf(5) for more information.
--purge-extra-packages
This is an experimental option. Only use when you know what you are doing. Source packages must
be buildable with only their build dependencies, all packages marked as Essential:yes, the build-
essential package and their transitive dependencies installed. But by default, most chroots will
also include Priority:required packages and apt as well as their transitive dependencies. This
option will try to remove all additional packages that are not strictly required for the build
right after build dependencies were installed. This currently works best with the aspcud resolver.
The apt resolver will not make as much effort to remove all unneeded packages and will keep all
providers of a virtual package and all packages from any dependency alternative that happen to be
installed. The aptitude and xapt resolver do not implement this feature yet. The removed packages
are not (yet) added again after the build finished. This can have undesirable side effects like
lintian not working (because there is no apt to install its dependencies) or bare chroots becoming
totally unusable after apt was removed from them. Thus, this option should only be used with
throw-away chroots like schroot provides them where the original state is automatically restored
after each build. This command line option sets the PURGE_EXTRA_PACKAGES configuration variable.
See sbuild.conf(5) for more information.
--bd-uninstallable-explainer=dose3|apt
If the build dependencies cannot be satisfied by the chosen resolver, sbuild will run the selected
method to give a better explanation why the build dependencies cannot be installed. Possible
arguments for this option are dose3 (the default) and apt. To disable this feature, pass the empty
string. Depending on the resolver, the dose3 explainer might report a dependency situation as
satisfiable even if the chosen resolver found it to be unsatisfiable. This is especially likely to
happen if the apt resolver (the default) is used. Such disparities can have two reasons: either
the understanding of the involved dependency situation of the apt and dose3 solver differs (this
is a bug) or the apt solver was unable to find a solution if the dependency situation is not
trivial (for example if it involves packages from multiple repositories). In the former case,
please report the disparity as a bug against the resolvers. In the latter case, use a resolver
that is more likely to find a solution like the aptitude or aspcud resolvers. Especially the
aspcud resolver should find a solution if and only if the dose3 solver also finds one. This
command line option sets the BD_UNINSTALLABLE_EXPLAINER configuration variable. See sbuild.conf(5)
for more information.
CHROOT MODES
The main purpose of sbuild is to build Debian packages in a clean chroot environment. Provisioning and
managing these chroot environments is not done by sbuild itself but by multiple backends. The default
backend (or chroot mode) is schroot which is an suid binary that allows regular users to enter a chroot
environment. But sbuild also allows one to build packages in a qemu virtual machine, lxc, lxd or on a
remote host reached by ssh using the autopkgtest backend. The backend can be chosen using the --chroot-
mode command line argument or the $chroot_mode configuration parameter.
schroot
The default and recommended chroot mode. It is also used on Debian buildd machines. The easiest
way to set up sbuild for use with the schroot backend is by using sbuild-createchroot which will
also write out the necessary schroot configuration files in /etc. To use the chroots, the current
user has to be added to the sbuild group, for example by running sbuild-adduser. Updating these
schroot backends can be done using sbuild-update. See the respective man pages for more
information about how to use these programs. Schroot supports chroots from directories, tarballs,
filesystem images and block devices. Schroot provides ephemeral chroots either by unpacking a
tarball into a temporary directory, by using an overlay filesystem for directory chroots or by
using btrfs or lvm snapshots. Chroots usable by schroot are defined by configuration files in
/etc/schroot/chroot.d/. When building for a specific distribution and architecture, sbuild will
choose the chroot that is named (or has the alias) $distribution-$arch-sbuild,
$distribution-sbuild, $distribution-$arch or $distribution, in that order of preference. The used
chroot name can be overridden using the -c or --chroot options.
sudo This chroot mode is deprecated and only provided for backwards compatibility and testing purposes.
It operates by plainly entering the chosen chroot directory using "sudo chroot". Thus, this
backend also does not provide ephemeral chroots. The sudo chroot mode searches for a symlink or
directory located at /etc/sbuild/chroot/ or in the current directory, prefixed with chroot-. The
expected names are resolved in the same order as for the schroot chroot mode and can be overridden
using the -c or --chroot options.
autopkgtest
This is an experimental chroot mode that allows one to build packages in any chroot supported by
autopkgtest. This allows one to build packages in lxc or lxd containers, a qemu virtual machine or
on a remote host via ssh. Which autopkgtest server to use is determined via the --autopkgtest-
virt-server option. Since autopkgtest (in contrast to schroot) does not maintain a registry of
available containers or (virtual) machines, it is necessary to manually specify them using the
--autopkgtest-virt-server-opts= command line argument. To avoid having to manually type the right
container or machine name every time when sbuild is executed, percent escapes are permitted.
unshare
This is an experimental backend that allows one to build packages inside chroots provided by
arbitrary tarballs. This allows one to set up an arbitrary build environment without having to
become root. Building packages with schroot also doesn't require sudo (schroot is suid root) but
setting up and updating chroots requires superuser permissions. The unshare backend only makes use
of two small suid binaries (newuidmap and newgidmap) and only requires root once for enabling
unprivileged userns clones (Debian carries a patch against the Linux kernel that disables this
feature by detault). So after setting kernel.unprivileged_userns_clone=1 /etc/sysctl.d/, this
backend allows arbitrary tarballs containing chroot environments to be used for package building.
The default tarball location is in ~/.cache/sbuild/. The expected names are resolved in the same
order as for the schroot chroot mode and can be overridden using the -c or --chroot options.
BUILD ARTIFACTS
Sbuild is meant to be used to build architecture specific binary packages from a given source package. In
addition, sbuild is also able to generate architecture independent binary packages as well as to rebuild
the original source package that was used as input. In summary, sbuild is able to build architecture
specific binary packages, architecture independent binary packages and source packages. What ends up
being built is determined by the configuration variables BUILD_ARCH_ANY, BUILD_ARCH_ALL and BUILD_SOURCE,
respectively. See sbuild.conf(5) for a detailed explanation of these configuration variables.
By default, during native compilation, BUILD_ARCH_ANY and BUILD_ARCH_ALL are set to true while
BUILD_SOURCE is set to false. During cross-compilation, BUILD_ARCH_ALL defaults to false. This
behaviour can be changed either by using command line options or by modifying the configuration variables
in your ~/.sbuildrc. The relevant command line options to change the values of BUILD_ARCH_ANY,
BUILD_ARCH_ALL and BUILD_SOURCE are --arch-any/--no-arch-any, --arch-all/--no-arch-all and --source/--no-
source, respectively.
The values of BUILD_ARCH_ANY, BUILD_ARCH_ALL and BUILD_SOURCE change the parameter that dpkg-buildpackage
is called with. The following table displays the argument passed to dpkg-buildpackage in the last column
depending on the configuration options in the first three columns.
BUILD_ARCH_ANY BUILD_ARCH_ALL BUILD_SOURCE dpkg-buildpackage flag
────────────────────────────────────────────────────────────────────────
false false false invalid
false false true -S
false true false -A
false true true -g
true false false -B
true false true -G
true true false -b
true true true no option
EXTERNAL COMMANDS
Support to run external commands during an sbuild run is provided. A set of external commands can be run
at various stages of a build. Providing commands to run is done through the appropriate options given on
the command line and through the use of the configuration files. In the configuration file, the list of
commands to run are placed in a hash of arrays of arrays of strings corresponding to the commands to run.
There are several sets of commands. All command are run inside the chroot as root except for the
pre/post-build- commands which are run as the user running sbuild outside of the chroot. To run an
external command as another user than the root user, prefix your command with runuser -u sbuild --.
Here is a summary of the ordering, user, internal/external to chroot for each command hook
The following table shows each command hook in the context of the tasks sbuild performs. The column root
shows whether the command is run as root (yes) or not (no). The column chroot shows whether the command
is run inside our outside the chroot. The working directory inside the chroot is the one marked with
<<BUILDDIR>> inside the log. By default, this is a directory of the format /build/packagename-XXXXXX/
where XXXXXX is a random ascii string. Otherwise, it is the directory set by --build-path or by the
BUILD_PATH configuration option. The working directory outside of the chroot is $HOME. The remaining
columns show the percent escapes that are defined in each command. Percent escapes that are available in
all commands (%%, %a, %b, %s) are omitted. The value maybe in the column for the %d and %p escapes means
that the value can not relied upon to be defined in these stages. More specifically, these escapes will
not be defined at these points if the user specified a source package name without a version on the
command line. In that case, the version will only become known after the source package has been
retrieved in the "Fetch and unpack source package" stage.
command/action root chroot %c %e %d,%p
──────────────────────────────────────────────────────────────────────────
Initialise chroot session
--pre-build-commands no outside no yes maybe
Setup the chroot and variables
--chroot-setup-commands yes inside no no maybe
Update and upgrade packages
--chroot-update-failed-commands yes inside no no maybe
Fetch and unpack source package
Install Dependencies
--build-deps-failed-commands yes inside no no yes
--starting-build-commands yes inside no no yes
Run dpkg-buildpackage
--build-failed-commands yes inside no no yes
--finished-build-commands yes inside no no yes
Run lintian (if configured)
--chroot-cleanup-commands yes inside yes no yes
Cleanup build files and dependencies
Run piuparts (if configured)
Run autopkgtest (if configured)
Close schroot session
--post-build-commands no outside yes yes yes
--post-build-failed-commands no outside yes yes yes
The commands can be given in the configuration files. They can be given as strings or as a list of
arguments. For example, to run "foo" and "bar" with arguments before a build starts, specifying the "foo"
command as a list and "bar" as a string, one could do this:
$external_commands = {
"pre-build-commands" => [
['foo', 'arg1', 'arg2'],
'bar arg1 arg2 arg3',
],
};
Hash keys for commands to run at other stages have the same name as their corresponding command-line
option name without the preceding '--'.
Here's an example of how to do the same with the previous example, except using the --pre-build-commands
option.
$ sbuild \
--pre-build-commands='foo arg1 arg2' \
--pre-build-commands='bar arg1 arg2 arg3'
Note that all these commands are executed through the shell in "/bin/sh". If specifying the command as a
list in the config file, very few shell facilities are supported: no redirection, no command
concatenation with ; and so on. When passing a string (in the config file or on the commandline), the
string is passed as-is to the shell. So all shell facilities are available, given that you escape
everything properly, as you would in an interactive shell.
Besides running external commands, sbuild can also detect the use of certain percent escapes given as
arguments. These are used to allow for a command to be supplied with a certain argument depending on the
escape given. For example, it could be possible to have an external command be given the path to a
.changes file.
Here is a listing of keywords and a description of what it's converted to.
%% Used to escape a '%'.
%d, %SBUILD_DSC
These escapes are converted to the absolute path to a package's .dsc file.
%c, %SBUILD_CHANGES
These escapes are converted to the absolute path to a package's source .changes file. This is the
.changes file generated by the dpkg-buildpackage invocation and not the source-only .changes file
that might've been produced additionally via --source-only-changes. This variable is only set
after the build is finished, i.e in --chroot-cleanup-commands, --post-build-commands, and
--post-build-failed-commands.
%a, %SBUILD_HOST_ARCH
These escapes are converted to the debian name of the architecture the build is being built for
(e.g amd64, armhf).
%e, %SBUILD_CHROOT_EXEC
These escapes are converted to a command which can be executed on a host and can be given
arguments which will then be executed inside the chroot. Standard input and output of the process
started inside the chroot are connected to the program executed on the host. Thus, this command
can also be used to copy data into the chroot and out of the chroot. The working directory of the
process started inside the chroot is the root directory of the chroot. The process is started as
the root user. This variable is not set if the external command is run inside the chroot. Thus
this escape is only available for --pre-build-commands, --post-build-commands, and
--post-build-failed-commands.
%b, %SBUILD_BUILD_DIR
These escapes are converted to the absolute path to the build directory inside the chroot.
%p, %SBUILD_PKGBUILD_DIR
These escapes are converted to the absolute path to the package build directory inside the chroot.
%s, %SBUILD_SHELL
This is converted to a command to spawn an interactive "bash" shell
%SBUILD_BUILD_ARCH
This escape is converted to the Debian name of the architecture that the build is being run on
(e.g amd64, armhf).
Percent escapes are only substituted when an appropriate value is defined for them. At other times, it is
left unchanged. In practice this means that there are only two escapes that are not available in all
external commands: %c and %e. For example, a .changes file is only defined at the end of a build, so
using %c will only be substituted for post-build-commands and post-build-failed-commands.
Here's an example of using an escape to run a program foo on a .changes file after a build is done.
$ sbuild --post-build-commands \
'foo %SBUILD_CHANGES'
And here's an example that will spawn an interactive shell to investigate the problem whenever the build
failed:
$ sbuild --build-failed-commands '%SBUILD_SHELL'
The following example would copy a file from the host into the chroot:
$ sbuild --pre-build-commands \
'cat blub.txt | %SBUILD_CHROOT_EXEC sh -c "cat > blub.txt"'
One final note, external commands are processed in the order they are given. Also, the commands given in
a configuration file are processed first, then the commands given through the command line options.
OPTION STRING PERCENT ESCAPES
Besides for external command strings, percent escapes can also be used in custom options passed to
piuparts, autopkgtest and the chosen autopkgtest-virt server. This is for example useful for
communicating the right chroot backend to piuparts or autopkgtest depending on the distribution or
architecture the source package was built for.
Here is a listing of keywords and a description of what it's converted to.
%% Used to escape a '%'.
%a, %SBUILD_HOST_ARCH
These escapes are converted to the debian name of the architecture the build is being built for
(e.g amd64, armhf).
%r, %SBUILD_DISTRIBUTION
The distribution that the source package was built for. This is the value recorded in
debian/changelog or the value passed via the --dist option. Mnemonic: the r is the first letter
in "release".
Here is an example that will run piuparts with the right schroot chroot:
$ sbuild --run-piuparts \
--piuparts-opts="--schroot=%r-%a-sbuild"
Or an example of running autopkgtest with the right schroot chroot:
$ sbuild --run-autopkgtest --autopkgtest-root-args= \
--autopkgtest-opts="-- schroot %r-%a-sbuild"
To achieve the same effect via the configuration file, add the following:
$autopkgtest_root_args = '';
$piuparts_opts = [ '--schroot=%r-%a-sbuild' ];
$autopkgtest_opts = [ '--', 'schroot', '%r-%a-sbuild' ];
The --autopkgtest-root-args option and the $autopkgtest_root_args configuration variable are set to the
empty string because the default is to run autopkgtest with "sudo --" in front of it which is not needed
with the schroot autopkgtest backend.
LOCAL ARCHIVE
The apt and aptitude resolvers create a local archive for installing build dependencies. This is an
internal implementation detail of the build dependency resolver, which is not user configurable, and is
intended to be entirely transparent to the user. The local archive exists only transiently during the
package build. It does not persist across builds, and it is only used to store the dummy dependency
packages created for a single build.
The dependency resolvers do the following:
• Create a dummy dependency package. This contains the Build-Depends (and optionally Build-Depends-
Arch and Build-Depends-Indep) as Depends, and Build-Conflicts (and optionally Build-Conflicts-Arch
and Build-Conflicts-Indep) as Conflicts.
• Install the dummy dependency package into the local archive,
• Generate the Packages, Sources and Release files.
• Write a sources.list file for the local archive into /etc/apt/sources.list.d.
• Inject the lists directly into /var/lib/apt/lists. This step is to save running updating all apt
sources which is undesirable during a build; apt and aptitude do not support updating a single
source at present.
• Regenerate the apt caches to ensure everything is in sync.
• Install the dummy dependency package with apt or aptitude; the dummy package is pulled from the
local apt archive, while all its dependencies are pulled from the regular configured apt sources.
At the end of the build, the local archive is removed, along with the rest of the build tree.
EXAMPLES
Before you use sbuild for the first time, you have to do some setup depending on the chroot mode you are
using. The default chroot mode is schroot. To use sbuild with the schroot backend, you need to add your
user to the sbuild group and create a schroot chroot. The latter can be accomplished by using sbuild-
createchroot(8). After this one time setup, you can now use sbuild to build packages like this:
% sbuild -d unstable bash
Or on a .dsc:
% sbuild -d unstable bash.dsc
Or from within an unpacked source package (the -d parameter is not necessary here because the
distribution is inferred from debian/changelog):
% sbuild
ENVIRONMENT VARIABLES
The following environment variables are used by sbuild:
HOME The home directory of the user.
LOGNAME
Used in lockfiles.
SBUILD_CONFIG
Path to an additional configuration file on top of the system wide and user specific ones.
FILES
/etc/sbuild/sbuild.conf
Configuration, maintained by the system administrator. This may be used to override the defaults.
/etc/sbuild/chroot
Directory containing symbolic links to chroots. This is only used for sudo chroot access; schroot
access uses the schroot chroot configuration.
~/.sbuildrc
User-specific configuration. A custom path to a configuration file can also be specified through
setting the SBUILD_CONFIG environment variable to the path of an additional configuration file.
/var/lib/sbuild
Build trees, archive signing keys, build statistics and lock files.
AUTHORS
Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de>.
sbuild is based on debbuild, written by James Troup <james@nocrew.org> and has been modified by
Ben Collins <bcollins@debian.org>,
Ryan Murray <rmurray@debian.org>,
Francesco Paolo Lovergine <frankie@debian.org>,
Michael Banck <mbanck@debian.org>, and
Roger Leigh <rleigh@debian.org>
COPYRIGHT
Copyright © 1998-2000 Roman Hodek <roman@hodek.net>
Copyright © 1998-1999 James Troup <troup@debian.org>
Copyright © 2003-2006 Ryan Murray <rmurray@debian.org>
Copyright © 2001-2003 Rick Younie <younie@debian.org>
Copyright © 2003-2004 Francesco Paolo Lovergine <frankie@debian.org>
Copyright © 2005 Michael Banck <mbanck@debian.org>
Copyright © 2005-2009 Roger Leigh <rleigh@debian.org>
SEE ALSO
sbuild.conf(5), sbuild-abort(1), sbuild-adduser(8), sbuild-apt(1), sbuild-checkpackages(1),
sbuild-createchroot(8), sbuild-distupgrade(1), sbuild-hold(1), sbuild-setup(7). sbuild-shell(1),
sbuild-unhold(1), sbuild-update(1), sbuild-upgrade(1), schroot(1),