Target is essentially a Linux distribution installed on your development workstation that you’re going to build and package software for. Target consists of:
$HOME/.ldbox directory.Target is created by extracting contents of distribution’s root
filesystem contents into some directory and then running
lb-init command inside this directory.
Mapping mode contains the following set of rules.
fs_rules specify how real filesystem directories are
mepped into virtual filesystem view.exec_rules specify how new executables are started and
how their executable name and arguments are modified.Networking mode contains set of rules specifying what kind of access to network is allowed and which IP addresses a process can connect and bind to.
CPU transparency method is a method to run binaries for
architectures that are incompatible to architecture of the host system.
CPU transparency method is defined in lb-init command line
arguments when creating a new target, so it’s stored in target’s
metadata. Usually dynamically linked qemu is used as cpu transparency
method. CPU transparency method is run inside the same emulated
environment, so the same mapping and network mode rules are applied to
emulated program.
If target architecture is incompatible with the host one, all target
binaries can be run using CPU transparency method only. Usually this is
slow because target CPU emulation is needed. For most of the frequently
used Linux utilities, a host’s native binary that is doing exactly the
same can be used instead. For example, software build process can be
sped up significantly if native versions of make,
sed, grep and even bash are used
instead of emulated ones. These native binaries are calles
tools (or build tools).
It’s important that utilities from tools were built using the same compilation flags and have exactly the same versions as emulated utilities from the target. Otherwise subtle differences os behaviour and accepted command line arguments can lead to difficult to diagnose build failures. Hence, it’s advisable to use tools built for the same version of the same distribution as the one in the target.
If the target distribution is the same as the one host system runs, you can use tools directly from the system. Otherwise, you have to put tools to some directory that is different than target root. A directory containing tools is called tool root.
Native tools must have the same pathnames relatively to the tool
root, as corresponding target utilities have relatively to the target
root. For example, if sed utility is
/usr/bin/sed in your target distribution, then it will be
located in ${target_root}/usr/bin/sed (where
${target_root} is target root) on host system, so
corresponding native tool should be in
${tool_root}/usr/bin/sed (where ${tool_root}
is tool root).
Binaries located in tool root get their shared libraries from tool root like if they were running chrooted there, but access other files from target root, according to target’s mapping modes.
Tool root is defined in lb-init command line arguments
when creating a new target, so it’s stored in target’s metadata.
A special case of build tool is compiler and other compiler-related programs (preprocessor, assembler, link editor). The common name for all these tools is toolchain.
The full compiler pathname and additional compiler options are
defined in lb-init command line arguments when creating a
new target, so they are stored in target’s metadata.
Compiler specified this way is used instead of target’s compiler. Toolchain can be located anywhere: in target root, in tool root, or somewhere else. The mapping rules for running toolchain binaries are selected according to their location. For example, if they’re located in tool root, they are run the same way as other tools from tool root.
Session is a group of processes running under
ldbox’s control. Usually session contains a process that
was started using lb command and its descendants, but there
is a way to attach to a running session and start additional processes
inside it. Target and mode should be specified when starting a new
session.
There can be multiple sessions running simultaneously. Some mappings
inside a session can be private. For example, usually a session has its
own /tmp directory, and its content is not visible in other
sessions.
Note that ldbox session is not the same as Linux
session. Usually, ldbox sessions run inside a Linux session
of logged in user, but there is a way to start ldbox
session inside new Linux session.