Differences between revisions 1 and 21 (spanning 20 versions)
Revision 1 as of 2015-05-20 18:32:01
Size: 4182
Editor: wookey
Comment:
Revision 21 as of 2017-09-27 14:37:05
Size: 8877
Editor: PaulWise
Comment: add an articles section
Deletions are marked like this. Additions are marked like this.
Line 3: Line 3:
You can build on your name system but it is recommended to use a chroot, because: You can build on your main system but it is recommended to use a chroot, because:
Line 8: Line 8:
This page documents the procedure using sbuild. (pbuilder could be used instead but sbuild is more capable).

== Install tools ==

You need sbuild installed. This will also bring in schroot and build-essential.
{{{
sudo apt-get install sbuild
}}}

== Set up a chroot ==

This can be done lots of ways (debootstrap, mksbuild, multistrap, pbuilder create). sbuild-createchroot is good because it does the schroot config for you too, and can make tarballs trivially, for clean builds.

{{{
sudo sbuild-createchroot --make-sbuild-tarball=/srv/chroots/jessie-sbuild.tgz jessie /srv/chroots/jessie http://httpredir.debian.org/debian/
}}}
will create a base chroot, pack it up into /srv/chroots/jessie-sbuild.tgz, and add the config for it to schroot (in /etc/schroot/chroot.d)

If you have not used sbuild before on this machine it needs setting up on your machine:
{{{
sudo sbuild-adduser <your-username>
}}}
to allow your username to run builds, and

{{{
sbuild-update --keygen
}}}
to enable installation of build-dependencies in the chroot. (This command can take a really long time on servers with insufficient entropy - running it locally and copying the keyfiles over to the build machine can be a good idea in that case)

Check the new chroot exists with
{{{
schroot -l
}}}

Which on an amd64 machine will display:
{{{
chroot:jessie-amd64-sbuild
source:jessie-amd64-sbuild
}}}
(sbuild-createchroot adds the arch name by default when naming chroots - this is quite useful if you have more than one)

== Changing the sources in the chroot ==

By default the apt sources for the build are the same as the ones in your main {{{/etc/apt/source.list}}}. Change them if that's not what you want:

First you need an editor in the chroot - there is none by default (choose vim.tiny, zile, nano) as you see fit). A few tools in the chroot are useful, but for clean builds you don't want too much stuff in there.
{{{
sudo sbuild-apt jessie-amd64-sbuild apt-get install zile
}}}

Now enter the chroot to edit {{{/etc/apt/sources.list}}} or {{{/etc/apt/sources.list.d/customsource.list}}}
{{{
sudo sbuild-shell jessie-amd64-sbuild
}}}

== Using the chroot ==

You can use the chroot in two ways:
 1. the clean chroot chroot:jessie-amd64-sbuild, where none of your changes are saved so it's the same every time.
 2. the actual chroot tarball source:jessie-amd64-sbuild, where changes are packaed up again and saved for next time.

Normally you use the clean chroot, and that's the default if you just say "jessie-amd64-sbuild" (the sbuild-shell command is an exception to this)
This page documents the both manual procedures and building using sbuild and pbuilder.

<<TableOfContents>>
Line 74: Line 14:
This is very simple if it works for you, as sbuild does a load of things for you and hides the complexity. However it won't work for all packages or all suites yet, see below for more detail.
 
Prerequisites:
 * an schroot chroot (to do builds in). See CrossCompiling#Install_tools below to set this up.

  
This is very simple if it works for you, as sbuild does a load of setup for you and hides the complexity. However it won't work for all packages or all suites yet. Jessie in particular needs extra setup as some piece are missing but from stretch onwards it should just work. You do need to have a chroot already setup (detailed below).
Line 91: Line 35:
Sbuild assumes that a package called crossbuild-essential-$arch is available which is uses to install the cross-toolchain. This is not true in jessie. You can either install a crosstoolchain in the chroot if you only build for one arch, or you can use an external repo to add the missing bits. Sbuild assumes that a package called crossbuild-essential-$arch is available which is uses to install the cross-toolchain. This is not true in jessie. You can either install a crosstoolchain in the chroot if you only build for one arch, or you can use an external repo to add the missing bits.

=== Using the cross-toolchain repo ===

This repository has pre-built cross-toolchains. crossbuild-essential meta-packages and few other updated packages to improve the crossbuilding experience (dpkg-cross, pkg-config and a few multiarch-modified)

See https://wiki.debian.org/CrossToolchains#Installation for details.

=== Building your own cross-toolchain ===

Full details are at MultiarchCrossToolchainBuild

In summary, this should build you a cross-toolchain (for armhf)
{{{
sudo dpkg --add-architecture armhf
sudo apt-get update
sudo apt-get install cross-gcc-dev
#Make sure bash (or zsh) is your default shell or add SHELL:=/bin/bash to 2nd line of /usr/share/cross-gcc/template/rules.generic
TARGET_LIST="armhf" cross-gcc-gensource 4.9
cd cross-gcc-packages-amd64/cross-gcc-4.9-armhf
sudo apt-get install debhelper gcc-4.9-source libc6-dev:armhf linux-libc-dev:armhf libgcc1:armhf binutils-arm-linux-gnueabihf bison flex libtool gdb sharutils netbase libcloog-isl-dev libmpc-dev libmpfr-dev libgmp-dev systemtap-sdt-dev autogen expect chrpath zlib1g-dev zip
dpkg-buildpackage
}}}

== Building with pbuilder ==

You need to be pbuilder from stretch or jessie-backports (or newer) to support cross-building; the feature was introduced in version 0.227.

You must use the apt "satisfydepends" resolver with pbuilder. This can be done by adding the following line to your '''~/.pbuilderrc''' :
{{{
PBUILDERSATISFYDEPENDSCMD="/usr/lib/pbuilder/pbuilder-satisfydepends-apt"
}}}

If you're missing the above you might see the following error:
''E: Cross building is possible only with the APT dependency resolver''

(If you don't already have a pbuilder base chroot, create one now by simply running: {{{pbuilder create}}} )

Now to cross-building a package simply use the --host-arch option, eg. to build "my-package" for armhf use:
{{{
pbuilder build --host-arch armhf my-package.dsc
pdebuild -- --host-arch armhf
}}}
Line 95: Line 81:
If you are building packages with no library dependencies (such as kernels or bootloaders), and using a standalone cross-toolchain, then you don't need to enable the foreign architecture. Nearly all packages will need the foreign architecture enabling.
Line 97: Line 85:
dpkg --add-architecture armhf
apt-get update
}}}

{{{
apt-get build-dep -aarmhf <package>
sudo dpkg --add-architecture armhf
sudo apt-get update
sudo apt-get install build-essential crossbuild-essential-armhf
}}}

{{{
sudo apt-get build-dep -aarmhf <package>
Line 104: Line 93:
dpkg-buildpackage -aarmhf CONFIG_SITE=/etc/dpkg-cross/cross-config.<host_arch> DEB_BUILD_OPTIONS=nocheck dpkg-buildpackage -aarmhf
Line 111: Line 100:

-----

== Building manually outside of packages ==

You can look at the code for [[https://codesearch.debian.net/search?q=package:debhelper+is_cross_compiling|how debhelper does cross-compiling]].

The dpkg_architecture_value() function returns values that can be found in the output of the `dpkg-architecture` command.

== Install tools ==

You need sbuild installed. This will also bring in schroot and build-essential.
{{{
sudo apt-get install sbuild
}}}

== Set up a chroot ==

This can be done lots of ways (debootstrap, mksbuild, multistrap, pbuilder create). sbuild-createchroot is good because it does the schroot config for you too, and can make tarballs trivially, for clean builds.

{{{
sudo sbuild-createchroot --make-sbuild-tarball=/srv/chroots/jessie-sbuild.tgz jessie /srv/chroots/jessie http://httpredir.debian.org/debian/
}}}
will create a base chroot, pack it up into /srv/chroots/jessie-sbuild.tgz, and add the config for it to schroot (in /etc/schroot/chroot.d)

If you have not used sbuild before on this machine it needs setting up on your machine:
{{{
sudo sbuild-adduser <your-username>
}}}
to allow your username to run builds, and

{{{
sbuild-update --keygen
}}}
to enable installation of build-dependencies in the chroot. (This command can take a really long time on servers with insufficient entropy - running it locally and copying the keyfiles over to the build machine can be a good idea in that case)

Check the new chroot exists with
{{{
schroot -l
}}}

Which on an amd64 machine will display:
{{{
chroot:jessie-amd64-sbuild
source:jessie-amd64-sbuild
}}}
(sbuild-createchroot adds the arch name by default when naming chroots - this is quite useful if you have more than one)

That is one chroot, accessible in two different ways:
 1. the clean chroot chroot:jessie-amd64-sbuild, where none of your changes are saved so it's the same every time.
 2. the actual chroot tarball source:jessie-amd64-sbuild, where changes are packed up again and saved for next time.

Normally you use the clean chroot, and that's the default if you just say "jessie-amd64-sbuild" (the sbuild-shell command is an exception to this, as it implicitly uses the source: version)

== Changing the sources in the chroot ==

By default the apt sources for the build are the one given on the sbuild-createchroot command line. If that's not what you want you need to change them:

First you need an editor in the chroot - there is none by default (choose vim.tiny, zile, nano) as you see fit). A few tools in the chroot are useful, but for clean builds you don't want too much stuff in there.
{{{
sudo sbuild-apt jessie-amd64-sbuild apt-get install zile
}}}

Now enter the chroot to edit {{{/etc/apt/sources.list}}} or {{{/etc/apt/sources.list.d/customsource.list}}}
{{{
sudo sbuild-shell jessie-amd64-sbuild
}}}

=== Making your home dir available in the chroot ===

It's very handy to have your home directory automatically mounted in the chroot. The default sbuild-createchroot command does not set this up. If you only ever do sbuild-builds then it doesn't matter. But if you enter the chroot to run manual builds or tests having your home dir available is ''really'' useful.

Do this by changing
{{{
profile=sbuild
}}}
to
{{{
profile=default
}}}
in {{{/etc/schroot/chroot.d/jessie-amd64-sbuild-<uniqueID>}}}

== Using the chroot ==

Basic usage to enter the chroot:

{{{
schroot -c jessie-amd64-sbuild
}}}

Normal users and networking are available inside (and your home dir if you enabled that) so (if you install sudo) you can use sudo, download stuff, use files. If you are less interested in clean builds than conveninence then you can install lots of stuff permanently in the chroot.

Read the sbuild man pages for lots of clever stuff you can do. sbuild supports sessions, so once started you can leave and re-enter a chroot session. They can even be recovered after rebooting. The same commands can be run in multiple chroots. They can be updated from outside. command-hooks can be used to run things before builds, after builds, on entry etc.

Seeing how many schroot sessions you have (old ones can collect, and need tidying up sometimes):
{{{
schroot -la
}}}

== Configuring cross-toolchains in schroot ==


== Manual chroot setup ==

If you did not use sbuild-createchroot

== Articles ==

 * [[https://enricozini.org/blog/2017/debian/qt-cross-architecture-development-in-debian/|Qt cross-architecture development in Debian]] by Enrico Zini

Debian now has good support for crossbuilding packages using multiarch. This page describes how to do it.

You can build on your main system but it is recommended to use a chroot, because:

  • The build environment is clean, especially if you use a tarball/lvm snapshot
  • You don't end up with lots of build-deps and foreign architecture packages in your main system
  • There is no risk of accidentally messing up your system if something important gets swapped to the wrong architecture

This page documents the both manual procedures and building using sbuild and pbuilder.

Building with sbuild

Prerequisites:

This is very simple if it works for you, as sbuild does a load of setup for you and hides the complexity. However it won't work for all packages or all suites yet. Jessie in particular needs extra setup as some piece are missing but from stretch onwards it should just work. You do need to have a chroot already setup (detailed below).

Either download the package source, enter it and run sbuild, or give an explicit package_version

apt-get source acl
cd acl-2.2.52/
sbuild  --host=armhf -d jessie

or:

sbuild  --host=armhf -d jessie acl_2.2.52

Jessie wrinkles

Sbuild assumes that a package called crossbuild-essential-$arch is available which is uses to install the cross-toolchain. This is not true in jessie. You can either install a crosstoolchain in the chroot if you only build for one arch, or you can use an external repo to add the missing bits.

Using the cross-toolchain repo

This repository has pre-built cross-toolchains. crossbuild-essential meta-packages and few other updated packages to improve the crossbuilding experience (dpkg-cross, pkg-config and a few multiarch-modified)

See https://wiki.debian.org/CrossToolchains#Installation for details.

Building your own cross-toolchain

Full details are at MultiarchCrossToolchainBuild

In summary, this should build you a cross-toolchain (for armhf)

sudo dpkg --add-architecture armhf
sudo apt-get update
sudo apt-get install cross-gcc-dev
#Make sure bash (or zsh) is your default shell or add SHELL:=/bin/bash to 2nd line of /usr/share/cross-gcc/template/rules.generic
TARGET_LIST="armhf" cross-gcc-gensource 4.9
cd cross-gcc-packages-amd64/cross-gcc-4.9-armhf
sudo apt-get install debhelper gcc-4.9-source libc6-dev:armhf linux-libc-dev:armhf libgcc1:armhf binutils-arm-linux-gnueabihf bison flex libtool gdb sharutils netbase libcloog-isl-dev libmpc-dev libmpfr-dev libgmp-dev systemtap-sdt-dev autogen expect chrpath zlib1g-dev zip
dpkg-buildpackage

Building with pbuilder

You need to be pbuilder from stretch or jessie-backports (or newer) to support cross-building; the feature was introduced in version 0.227.

You must use the apt "satisfydepends" resolver with pbuilder. This can be done by adding the following line to your ~/.pbuilderrc :

PBUILDERSATISFYDEPENDSCMD="/usr/lib/pbuilder/pbuilder-satisfydepends-apt"

If you're missing the above you might see the following error: E: Cross building is possible only with the APT dependency resolver

(If you don't already have a pbuilder base chroot, create one now by simply running: pbuilder create )

Now to cross-building a package simply use the --host-arch option, eg. to build "my-package" for armhf use:

pbuilder build --host-arch armhf my-package.dsc
pdebuild -- --host-arch armhf

Building with dpkg-buildpackage

If you are building packages with no library dependencies (such as kernels or bootloaders), and using a standalone cross-toolchain, then you don't need to enable the foreign architecture. Nearly all packages will need the foreign architecture enabling.

Enable the foreign architecture

sudo dpkg --add-architecture armhf
sudo apt-get update
sudo apt-get install build-essential crossbuild-essential-armhf

sudo apt-get build-dep -aarmhf <package>
cd <package>-<version>
CONFIG_SITE=/etc/dpkg-cross/cross-config.<host_arch>  DEB_BUILD_OPTIONS=nocheck dpkg-buildpackage -aarmhf


more to come here


Building manually outside of packages

You can look at the code for how debhelper does cross-compiling.

The dpkg_architecture_value() function returns values that can be found in the output of the dpkg-architecture command.

Install tools

You need sbuild installed. This will also bring in schroot and build-essential.

sudo apt-get install sbuild

Set up a chroot

This can be done lots of ways (debootstrap, mksbuild, multistrap, pbuilder create). sbuild-createchroot is good because it does the schroot config for you too, and can make tarballs trivially, for clean builds.

sudo sbuild-createchroot --make-sbuild-tarball=/srv/chroots/jessie-sbuild.tgz jessie /srv/chroots/jessie http://httpredir.debian.org/debian/

will create a base chroot, pack it up into /srv/chroots/jessie-sbuild.tgz, and add the config for it to schroot (in /etc/schroot/chroot.d)

If you have not used sbuild before on this machine it needs setting up on your machine:

sudo sbuild-adduser <your-username>

to allow your username to run builds, and

sbuild-update --keygen

to enable installation of build-dependencies in the chroot. (This command can take a really long time on servers with insufficient entropy - running it locally and copying the keyfiles over to the build machine can be a good idea in that case)

Check the new chroot exists with

schroot -l

Which on an amd64 machine will display:

chroot:jessie-amd64-sbuild
source:jessie-amd64-sbuild

(sbuild-createchroot adds the arch name by default when naming chroots - this is quite useful if you have more than one)

That is one chroot, accessible in two different ways:

  1. the clean chroot chroot:jessie-amd64-sbuild, where none of your changes are saved so it's the same every time.
  2. the actual chroot tarball source:jessie-amd64-sbuild, where changes are packed up again and saved for next time.

Normally you use the clean chroot, and that's the default if you just say "jessie-amd64-sbuild" (the sbuild-shell command is an exception to this, as it implicitly uses the source: version)

Changing the sources in the chroot

By default the apt sources for the build are the one given on the sbuild-createchroot command line. If that's not what you want you need to change them:

First you need an editor in the chroot - there is none by default (choose vim.tiny, zile, nano) as you see fit). A few tools in the chroot are useful, but for clean builds you don't want too much stuff in there.

sudo sbuild-apt jessie-amd64-sbuild apt-get install zile

Now enter the chroot to edit /etc/apt/sources.list or /etc/apt/sources.list.d/customsource.list

sudo sbuild-shell jessie-amd64-sbuild

Making your home dir available in the chroot

It's very handy to have your home directory automatically mounted in the chroot. The default sbuild-createchroot command does not set this up. If you only ever do sbuild-builds then it doesn't matter. But if you enter the chroot to run manual builds or tests having your home dir available is really useful.

Do this by changing

profile=sbuild

to

profile=default

in /etc/schroot/chroot.d/jessie-amd64-sbuild-<uniqueID>

Using the chroot

Basic usage to enter the chroot:

schroot -c jessie-amd64-sbuild

Normal users and networking are available inside (and your home dir if you enabled that) so (if you install sudo) you can use sudo, download stuff, use files. If you are less interested in clean builds than conveninence then you can install lots of stuff permanently in the chroot.

Read the sbuild man pages for lots of clever stuff you can do. sbuild supports sessions, so once started you can leave and re-enter a chroot session. They can even be recovered after rebooting. The same commands can be run in multiple chroots. They can be updated from outside. command-hooks can be used to run things before builds, after builds, on entry etc.

Seeing how many schroot sessions you have (old ones can collect, and need tidying up sometimes):

schroot -la

Configuring cross-toolchains in schroot

Manual chroot setup

If you did not use sbuild-createchroot

Articles