summaryrefslogblamecommitdiffstats
path: root/rsb/configuration.rst
blob: 62fc07319de823797923e8eaca9a3f586b9ef5a4 (plain) (tree)
1
2
3
4
5
6
7
8
9







                                                
             






































                                                                               
                  




























                                                                               
                    





























































                                                                                                        
   










































                                                                                  
   


























                                                                                                
                   





























                                                                                
                    































































































                                                                               
               









                                                                               
              









































                                                                                
               































                                                                               
                     

















































                                                                               
                       


















                                                                               
                  











                                                                               
                     









                                                                            
                            













                                                                               
                            









                                                                              
           














































































































































































































                                                                                          
         
















                                                                               
         





































































































                                                                               
         








































                                                                                  
     



























































































                                                                                                
      





























































                                                                               
        





































                                                                                 
      






                                                                             
        

















                                                                             
     







                                                                               
        







                                                                                                     
        







                                                                              
        









                                                                               
          






                                                                              
       



































































                                                                                               
      


































                                                                              
     































                                                                                              
     




                                                                                 
        




                                                                               
      




                                                                              
       





















                                                                               
       












                                                                           
         




                                                                               
   











































































                                                                               
    









                                                                                 
       



                                                                                
        




                                                                           
     





                                                                          
     



                                                        
      



                                                    
           





                                                                            
              



                                                                               
.. comment SPDX-License-Identifier: CC-BY-SA-4.0

.. comment COPYRIGHT (c) 2012 - 2016.
.. comment Chris Johns <chrisj@rtems.org>

.. _Configuration:

Configuration
=============

The RTEMS Source Builder has two types of configuration data:

- Build Sets

- Package Build Configurations

By default these files can be located in two separate directories and
searched. The first directory is ``config`` in your current working directory
(``_topdir``) and the second is ``config`` located in the base directory of the
RTEMS Source Builder command you run (``_sbdir``). The RTEMS directory
``rtems``` located at the top of the RTEMS Source Builder source code is an
example of a specific build configuration directory. You can create custom or
private build configurations and if you run the RTEMS Source Builder command
from that directory your configurations will be used.

The configuration search path is a macro variable and is reference as
``%{_configdir}``. It's default is defined as::

    _configdir   : dir  optional<2>  %{_topdir}/config:%{_sbdir}/config <1>

.. topic:: Items:

  1. The ``_topdir`` is the directory you run the command from and ``_sbdir``
     is the location of the RTEMS Source Builder command.

  2. A macro definition in a macro file has 4 fields, the label, type,
     constraint and the definition.

Build set files have the file extension ``.bset`` and the package build
configuration files have the file extension of ``.cfg``. The ``sb-set-builder``
command will search for *build sets* and the ``sb-builder`` commands works with
package build configuration files.

Both types of configuration files use the ``#`` character as a comment
character. Anything after this character on the line is ignored. There is no
block comment.

Source and Patches
------------------

The RTEMS Source Builder provides a flexible way to manage source. Source and
patches are declare in configurations file using the ``source`` and ``patch``
directives. These are a single line containing a Universal Resource Location or
URL and can contain macros and shell expansions. The :ref:`prep` section
details the *source* and *patch* directives

The URL can reference remote and local source and patch resources. The
following schemes are provided:

``http``:
  Remote access using the HTTP protocol.

``https``:
  Remote access using the Secure HTTP protocol.

``ftp``:
  Remote access using the FTP protocol.

``git``:
  Remote access to a GIT repository.

``pm``:
  Remote access to a patch management repository.

``file``:
 Local access to an existing source directory.

HTTP, HTTPS, and FTP
~~~~~~~~~~~~~~~~~~~~

Remote access to TAR or ZIP files is provided using HTTP, HTTPS and FTP
protocols. The full URL provided is used to access the remote file including
any query components. The URL is parsed to extract the file component and the
local source directory is checked for that file. If the file is located locally
the remote file is not downloaded. Currently no other checks are made. If a
download fails you need to manually remove the file from the source directory
and start the build process again.

The URL can contain macros. These are expanded before issuing the request to
download the file. The standard GNU GCC compiler source URL is:

.. code-block:: auto

    %source set<1> gcc<2> ftp://ftp.gnu.org/gnu/gcc/gcc-%{gcc_version}/gcc-%{gcc_version}.tar.bz2

.. topic:: Items:

  1. The ``%source`` command's set command sets the source. The first is set
     and following sets are ignored.

  2. The source is part of the ``gcc`` group.

The type of compression is automatically detected from the file extension. The
supported compression formats are:

``gz``:
  GNU ZIP

``bzip2``:
  BZIP2

``zip``:
  ZIP

``xy``:
  XY

The output of the decompression tool is feed to the standard ``tar`` utility if
not a ZIP file and unpacked into the build directory. ZIP files are unpacked by
the decompression tool and all other files must be in the tar file format.

The ``%source`` directive typically supports a single source file tar or zip
file. The ``set`` command is used to set the URL for a specific source
group. The first set command encoutner is registered and any further set
commands are ignored. This allows you to define a base standard source location
and override it in build and architecture specific files. You can also add
extra source files to a group. This is typically done when a collection of
source is broken down in a number of smaller files and you require the full
package. The source's ``setup`` command must reide in the ``%prep:`` section
and it unpacks the source code ready to be built.

If the source URL references the GitHub API server https://api.github.com/ a
tarball of the specified version is download. For example the URL for the
STLINK project on GitHub and version is:

.. code-block:: auto

    %define stlink_version 3494c11
    %source set stlink https://api.github.com/repos/texane/stlink/texane-stlink-%{stlink_version}.tar.gz

GIT
~~~

A GIT repository can be cloned and used as source. The GIT repository resides
in the 'source' directory under the ``git`` directory. You can edit, update and
use the repository as you normally do and the results will used to build the
tools. This allows you to prepare and test patches in the build environment the
tools are built in. The GIT URL only supports the GIT protocol. You can control
the repository via the URL by appending options and arguments to the GIT
path. The options are delimited by ``?`` and option arguments are delimited
from the options with ``=``. The options are:

``protocol``:
  Use a specific protocol. The supported values are ``ssh``, ``git``, ``http``,
  ``https``, ``ftp``, ``ftps``, ``rsync``, and ``none``.

``branch``:
  Checkout the specified branch.

``pull``:
  Perform a pull to update the repository.

``fetch``:
  Perform a fetch to get any remote updates.

``reset``:
  Reset the repository. Useful to remove any local changes. You can pass the
  ``hard`` argument to force a hard reset.

An example is:

.. code-block:: auto

    %source set gcc git://gcc.gnu.org/git/gcc.git?branch=gcc-4_7-branch?reset=hard

This will clone the GCC git repository and checkout the 4.7-branch and perform
a hard reset. You can select specific branches and apply patches. The
repository is cleaned up before each build to avoid various version control
errors that can arise.

The protocol option lets you set a specific protocol. The ``git://`` prefix
used by the RSB to select a git repository can be removed using *none* or
replaced with one of the standard git protcols.

CVS
~~~

A CVS repository can be checked out. CVS is more complex than GIT to handle
because of the modules support. This can effect the paths the source ends up
in. The CVS URL only supports the CVS protocol. You can control the repository
via the URL by appending options and arguments to the CVS path. The options are
delimited by ``?`` and option arguments are delimited from the options with
``=``. The options are:

``module``:
  The module to checkout.

``src-prefix``:
  The path into the source where the module starts.

``tag``:
  The CVS tag to checkout.

``date``:
  The CVS date to checkout.

The following is an example of checking out from a CVS repository:

.. code-block:: auto

    %source set newlib cvs://pserver:anoncvs@sourceware.org/cvs/src?module=newlib?src-prefix=src

Macros and Defaults
-------------------

The RTEMS Source Builder uses tables of *macros* read in when the tool
runs. The initial global set of macros is called the *defaults*. These values
are read from a file called ``defaults.mc`` and modified to suite your
host. This host specific adaption lets the Source Builder handle differences in
the build hosts.

Build set and configuration files can define new values updating and extending
the global macro table. For example builds are given a release number. This is
typically a single number at the end of the package name. For example::

    %define release 1

Once defined if can be accessed in a build set or package configuration file
with::

    %{release}

The ``sb-defaults`` command lists the defaults for your host. I will not include
the output of this command because of its size::

    $ ../source-builder/sb-defaults

A nested build set is given a separate copy of the global macro maps. Changes
in one change set are not seen in other build sets. That same happens with
configuration files unless inline includes are used. Inline includes are seen
as part of the same build set and configuration and changes are global to that
build set and configuration.

Macro Maps and Files
~~~~~~~~~~~~~~~~~~~~

Macros are read in from files when the tool starts. The default settings are
read from the defaults macro file called ``defaults.mc`` located in the top
level RTEMS Source Builder command directory. User macros can be read in at
start up by using the ``--macros`` command line option.

The format for a macro in macro files is::

  Name Type Attribute String

where ``Name`` is a case insensitive macro name, the ``Type`` field is:

``none``:
  Nothing, ignore.

``dir``:
  A directory path.

``exe``:
  An executable path.

``triplet``:
  A GNU style architecture, platform, operating system string.

the ``Attribute`` field is:

``none``:
  Nothing, ignore

``required``:
  The host check must find the executable or path.

``optional``:
  The host check generates a warning if not found.

``override``:
  Only valid outside of the ``global`` map to indicate this macro overrides the
  same one in the ``global`` map when the map containing it is selected.

``undefine``:
  Only valid outside of the ``global`` map to undefine the macro if it exists
  in the ``global`` map when the map containing it is selected. The ``global``
  map's macro is not visible but still exists.

and the ``String`` field is a single or tripled multiline quoted string. The
'String' can contain references to other macros. Macro that loop are not
currently detected and will cause the tool to lock up.

Maps are declared anywhere in the map using the map directive::

    # Comments
    [my-special-map] <1>
    _host:  none, override, 'abc-xyz'
    multiline: none, override, '''First line,
    second line,
    and finally the last line'''

.. topic:: Items:

  1. The map is set to ``my-special-map``.

Any macro defintions following a map declaration are placed in that map and the
default map is ``global`` when loading a file. Maps are selected in
configuration files by using the ``%select`` directive::

    %select my-special-map

Selecting a map means all requests for a macro first check the selected map and
if present return that value else the ``global`` map is used. Any new macros or
changes update only the ``global`` map. This may change in future releases so
please make sure you use the ``override`` attribute.

The macro files specificed on the command line are looked for in the
``_configdir`` paths. See <<X1,``_configdir``>> variable for details. Included
files need to add the ``%{_configdir}`` macro to the start of the file.

Macro map files can include other macro map files using the ``%include``
directive. The macro map to build *binutils*, *gcc*, *newlib*, *gdb* and
RTEMS from version control heads is::

    # <1>
    # Build all tool parts from version control head.
    #
    %include %{_configdir}/snapshots/binutils-head.mc
    %include %{_configdir}/snapshots/gcc-head.mc
    %include %{_configdir}/snapshots/newlib-head.mc
    %include %{_configdir}/snapshots/gdb-head.mc

.. topic:: Items:

  1. The file is ``config/snapshots/binutils-gcc-newlib-gdb-head.mc``.

The macro map defaults to ``global`` at the start of each included file and the
map setting of the macro file including the other macro files does not change.

Personal Macros
~~~~~~~~~~~~~~~

When the tools start to run they will load personal macros. Personal macros are
in the standard format for macros in a file. There are two places personal
macros can be configured. The first is the environment variable
``RSB_MACROS``. If present the macros from the file the environment variable
points to are loaded. The second is a file called ``.rsb_macros`` in your home
directory. You need to have the environment variable ``HOME`` defined for this
work.

Report Mailing
--------------

The build reports can be mailed to a specific email address to logging and
monitoring. Mailing requires a number of parameters to function. These are:

- To mail address

- From mail address

- SMTP host

.. _To Mail Address:

The ``to`` mail address is taken from the macro ``%{_mail_tools_to}`` and the
default is *rtems-tooltestresults at rtems.org*. You can override the default
with a personal or user macro file or via the command line option
``--mail-to``.

.. _From Mail Address:

The ``from`` mail address is taken from:

- GIT configuration

- User ``.mailrc`` file

- Command line

If you have configured an email and name in git it will be used used. If you do
not a check is made for a ``.mailrc`` file. The environment variable ``MAILRC``
is used if present else your home directory is check. If found the file is
scanned for the ``from`` setting::

  set from="Foo Bar <foo@bar>"

You can also support a from address on the command line with the ``--mail-from``
option.

The SMTP host is taken from the macro ``%{_mail_smtp_host}`` and the
default is ``localhost``. You can override the default with a personal
or user macro file or via the command line option ``--smtp-host``.

Build Set Files
---------------

Build set files lets you list the packages in the build set you are defining
and have a file extension of ``.bset``. Build sets can define macro variables,
inline include other files and reference other build set or package
configuration files.

Defining macros is performed with the ``%define`` macro::

    %define _target m32r-rtems4.11

Inline including another file with the ``%include`` macro continues processing
with the specified file returning to carry on from just after the include
point::

    %include rtems-4.11-base.bset

This includes the RTEMS 4.11 base set of defines and checks. The configuration
paths as defined by ``_configdir`` are scanned. The file extension is optional.

You reference build set or package configuration files by placing the file name
on a single line::

    tools/rtems-binutils-2.22-1

The ``_configdir`` path is scanned for ``tools/rtems-binutils-2.22-1.bset`` or
``tools/rtems-binutils-2.22-1.cfg``. Build set files take precedent over
package configuration files. If ``tools/rtems-binutils-2.22-1`` is a build set
a new instance of the build set processor is created and if the file is a
package configuration the package is built with the package builder. This all
happens once the build set file has finished being scanned.

Configuration Control
---------------------

The RTEMS Souce Builder is designed to fit within most verification and
validation processes. All of the RTEMS Source Builder is source code. The
Python code is source and comes with a commercial friendly license. All
configuration data is text and can be read or parsed with standard text based
tools.

File naming provides configuration management. A specific version of a package
is captured in a specific set of configuration files. The top level
configuration file referenced in a *build set* or passed to the ``sb-builder``
command relates to a specific configuration of the package being built. For
example the RTEMS configuration file ``rtems-gcc-4.7.2-newlib-2.0.0-1.cfg``
creates an RTEMS GCC and Newlib package where the GCC version is 4.7.2, the
Newlib version is 2.0.0, plus any RTEMS specific patches that related to this
version. The configuration defines the version numbers of the various parts
that make up this package::

    %define gcc_version    4.7.2
    %define newlib_version 2.0.0
    %define mpfr_version   3.0.1
    %define mpc_version    0.8.2
    %define gmp_version    5.0.5

The package build options, if there are any are also defined::

    %define with_threads 1
    %define with_plugin  0
    %define with_iconv   1

The generic configuration may provide defaults in case options are not
specified. The patches this specific version of the package requires can be
included::

    Patch0: gcc-4.7.2-rtems4.11-20121026.diff

Finally including the GCC 4.7 configuration script::

    %include %{_configdir}/gcc-4.7-1.cfg

The ``gcc-4.7-1.cfg`` file is a generic script to build a GCC 4.7 compiler with
Newlib. It is not specific to RTEMS. A bare no operating system tool set can be
built with this file.

The ``-1`` part of the file names is a revision. The GCC 4.7 script maybe
revised to fix a problem and if this fix effects an existing script the file is
copied and given a ``-2`` revision number. Any dependent scripts referencing
the earlier revision number will not be effected by the change. This locks down
a specific configuration over time.

Personal Configurations
-----------------------

The RSB supports personal configurations. You can view the RTEMS support in the
``rtems`` directory as a private configuration tree that resides within the RSB
source. There is also the ``bare`` set of configurations. You can create your
own configurations away from the RSB source tree yet use all that the RSB
provides.

To create a private configuration change to a suitable directory::

    $ cd ~/work
    $ mkdir test
    $ cd test
    $ mkdir config

and create a ``config`` directory. Here you can add a new configuration or
build set file. The section 'Adding New Configurations' details how to add a
new confguration.

New Configurations
------------------

This section describes how to add a new configuration to the RSB. We will add a
configuration to build the Device Tree Compiler. The Device Tree Compiler or
DTC is part of the Flattened Device Tree project and compiles Device Tree
Source (DTS) files into Device Tree Blobs (DTB). DTB files can be loaded by
operating systems and used to locate the various resources such as base
addresses of devices or interrupt numbers allocated to devices. The Device Tree
Compiler source code can be downloaded from http://www.jdl.com/software. The
DTC is supported in the RSB and you can find the configuration files under the
``bare/config`` tree. I suggest you have a brief look over these files.

Layering by Including
~~~~~~~~~~~~~~~~~~~~~

Configurations can be layered using the ``%include`` directive. The user
invokes the outer layers which include inner layers until all the required
configuration is present and the package can be built. The outer layers can
provide high level details such as the version and the release and the inner
layers provide generic configuration details that do not change from one
release to another. Macro variables are used to provide the specific
configuration details.

Configuration File Numbering
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Configuration files have a number at the end. This is a release number for that
configuration and it gives us the ability to track a specific configuration for
a specific version. For example lets say the developers of the DTC package
change the build system from a single makefile to autoconf and automake between
version 1.3.0 and version 1.4.0. The configuration file used to build the
package would change have to change. If we did not number the configuration
files the ability to build 1.1.0, 1.2.0 or 1.3.0 would be lost if we update a
common configuration file to build an autoconf and automake version. For
version 1.2.0 the same build script can be used so we can share the same
configuration file between version 1.1.0 and version 1.2.0. An update to any
previous release lets us still build the package.

Common Configuration Scripts
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Common configuration scripts that are independent of version, platform and
architecture are useful to everyone. These live in the Source Builder's
configuration directory. Currently there are scripts to build binutils, expat,
DTC, GCC, GDB and libusb. These files contain the recipes to build these
package without the specific details of the versions or patches being
built. They expect to be wrapped by a configuration file that ties the package
to a specific version and optionally specific patches.

DTC Example
~~~~~~~~~~~

We will be building the DTC for your host rather than a package for RTEMS. We
will create a file called ``source-builder/config/dtc-1-1.cfg``. This is a
common script that can be used to build a specific version using a general
recipe. The file name is ``dtc-1-1.cfg`` where the ``cfg`` extension indicates
this is a configuration file. The first ``1`` says this is for the major
release 1 of the package and the last ``1`` is the build configuration version.

The file starts with some comments that detail the configuration. If there is
anything unusual about the configuration it is a good idea to add something in
the comments here. The comments are followed by a check for the release. In
this case if a release is not provided a default of 1 is used::

    #
    # DTC 1.x.x Version 1.
    #
    # This configuration file configure's, make's and install's DTC.
    #

    %if %{release} == %{nil}
    %define release 1
    %endif

The next section defines some information about the package. It does not effect
the build and is used to annotate the reports. It is recommended this
information is kept updated and accurate::

    Name:      dtc-%{dtc_version}-%{_host}-%{release}
    Summary:   Device Tree Compiler v%{dtc_version} for target %{_target} on host %{_host}
    Version:   %{dtc_version}
    Release:   %{release}
    URL: 	   http://www.jdl.com/software/
    BuildRoot: %{_tmppath}/%{name}-root-%(%{__id_u} -n)

The next section defines the source and any patches. In this case there is a
single source package and it can be downloaded using the HTTP protocol. The RSB
knows this is GZip'ped tar file. If more than one package package is needed add
them increasing the index. The ``gcc-4.8-1.cfg`` configuration contains
examples of more than one source package as well as conditionally including
source packages based on the outer configuration options::

    #
    # Source
    #
    %source set dtc http://www.jdl.com/software/dtc-v%{dtc_version}.tgz

The remainder of the script is broken in to the various phases of a build. They
are:

. Preperation
. Bulding
. Installing, and
. Cleaning

Preparation is the unpacking of the source, applying any patches as well as any
package specific set ups. This part of the script is a standard Unix shell
script. Be careful with the use of ``%`` and ``$``. The RSB uses ``%`` while
the shell scripts use ``$``.

A standard pattern you will observe is the saving of the build's top
directory. This is used instead of changing into a subdirectory and then
changing to the parent when finished. Some hosts will change in a subdirectory
that is a link however changing to the parent does not change back to the
parent of the link rather it changes to the parent of the target of the link
and that is something the RSB nor you can track easily. The RSB configuration
script's are a collection of various subtle issues so please ask if you are
unsure why something is being done a particular way.

The preparation phase will often include source and patch setup commands. Outer
layers can set the source package and add patches as needed while being able to
use a common recipe for the build. Users can override the standard build and
supply a custom patch for testing using the user macro command line interface::

    #
    # Prepare the source code.
    #
    %prep
      build_top=$(pwd)

      %source setup dtc -q -n dtc-v%{dtc_version}
      %patch setup dtc -p1

      cd ${build_top}

The configuration file ``gcc-common-1.cfg`` is a complex example of source
preparation. It contains a number of source packages and patches and it
combines these into a single source tree for building. It uses links to map
source into the GCC source tree so GCC can be built using the *single source
tree* method. It also shows how to fetch source code from version
control. Newlib is taken directly from its CVS repository.

Next is the building phase and for the DTC example this is simply a matter of
running ``make``. Note the use of the RSB macros for commands. In the case of
``%{__make}`` it maps to the correct make for your host. In the case of BSD
systems we need to use the GNU make and not the GNU make.

If your package requires a configuration stage you need to run this before the
make stage. Again the GCC common configuration file provides a detailed example::

    %build
      build_top=$(pwd)

      cd dtc-v%{dtc_version}

      %{build_build_flags}

      %{__make} PREFIX=%{_prefix}

      cd ${build_top}

You can invoke make with the macro ``%{?_smp_flags}`` as a command line
argument. This macro is controlled by the ``--jobs`` command line option and
the host CPU detection support in the RSB. If you are on a multicore host you
can increase the build speed using this macro. It also lets you disabled
building on multicores to aid debugging when testing.

Next is the install phase. This phase is a little more complex because you may
be building a tar file and the end result of the build is never actually
installed into the prefix on the build host and you may not even have
permissions to perform a real install. Most packages install to the ``prefix``
and the prefix is typically supplied via the command to the RSB or the
package's default is used. The default can vary depending on the host's
operating system. To install to a path that is not the prefix the ``DESTDIR``