Changeset bb47f89 in rtems-docs


Ignore:
Timestamp:
Oct 13, 2019, 8:51:25 AM (5 weeks ago)
Author:
Chris Johns <chrisj@…>
Branches:
master
Children:
c576e9b
Parents:
6185f6e
git-author:
Chris Johns <chrisj@…> (10/13/19 08:51:25)
git-committer:
Chris Johns <chrisj@…> (10/13/19 09:21:17)
Message:

user/rsb: Update 3rd party package build and add packaging details.

Location:
user
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • user/rsb/configuration.rst

    r6185f6e rbb47f89  
    880880  Define a checksum for a source or patch file.
    881881
    882 ``%echo``:
     882``%{echo message}``:
    883883  Print the following string as a message.
    884884
    885 ``%warning``:
     885``%{warning message}``:
    886886  Print the following string as a warning and continue.
    887887
    888 ``%error``:
     888``%{error message}``:
    889889  Print the following string as an error and exit.
    890890
  • user/rsb/cross-canadian-cross.rst

    r6185f6e rbb47f89  
    1616^^^^^^^^^^^^^^
    1717
    18 Cross building is where the _build_ machine and _host_ are different. The
    19 _build_ machine runs the RSB and the _host_ machine is where the output from
    20 the build runs. An example is building a package such as NTP for RTEMS on your
     18Cross building is where the *build* machine and *host* are different. The
     19*build* machine runs the RSB and the *host* machine is where the output from
     20the build runs. An example is building a package such as Curl for RTEMS on your
    2121development machine.
    2222
    23 To build the NTP package for RTEMS you enter the RSB command:
     23To build the Curl package for RTEMS you enter the RSB command:
    2424
    2525.. code-block:: none
    2626
    2727    $ ../source-builder/sb-set-builder \
    28        --log=log_ntp_arm.txt \
     28       --log=log_curl_arm.txt \
    2929       --prefix=$HOME/development/rtems/5 \  <1>
    3030       --host=arm-rtems5 \  <2>
    3131       --with-rtems-bsp=xilinx_zynq_zc706 \  <3>
    32        5/net/ntp
     32       5/ftp/curl
    3333
    3434.. topic:: Items:
     
    4343.. note: Installing Into Different Directories
    4444
    45   If you install BSPs into a different path to the prefix use the
    46   ``--with-tools`` option to specify the path to the tools. Do not add the
    47   'bin' directory at the end of the path.
     45  If you use a prefix that is different to the path the build RTEMS BSP is
     46  installed under use the ``--with-rtems`` option to specify the top level path
     47  to the RTEMS BSP. Do not add an extra directories to the path,the RSB knows
     48  how to search the path.
     49
     50  If the tools have been installed in a different location to the RTEMS BSP and
     51  the prefix use the ``--with-tools`` option to specift the top level path to
     52  the installed tools Again do not add an extar directory such as ``bin`` as
     53  the RSB knows how to search the supplied tools path.
     54
     55  We recommend you install all thrid party packages using the same prefix.
     56  the RTEM BSP you can use the
    4857
    4958Canadian Cross Building
  • user/rsb/index.rst

    r6185f6e rbb47f89  
    77.. _RSB:
    88
    9 RTEMS Source Builder
    10 ********************
     9Source Builder
     10**************
    1111
    12 The RTEMS Source Builder or RSB is a tool to build packages from source. It is
    13 used by the RTEMS project to build it's compilers and OS. The RSB helps
    14 consolidate the details you need to build a package from source in a controlled
    15 and verifiable way. The tool is aimed at developers of software who use tool
    16 sets for embedded development. The RSB is not limited to building tools just
    17 for RTEMS, you can build bare metal development environments.
     12The RTEMS Source Builder or RSB is a tool to build packages from source. The
     13RTEMS project uses it to build it's compilers, tools, kernel and 3rd party
     14packages. The tool is aimed at developers of software for RTEMS who use tool
     15sets for embedded development.
     16
     17The RSB consolidates the details you need to build a package from source in a
     18controlled and verifiable way. The RSB is not limited to building tools for
     19RTEMS, you can build bare metal development environments.
     20
     21.. comment: TBD: The section "Installing and Tar Files" does not exist.
     22
     23The RSB section of this manual caters for a range of users from new to
     24experienced RTEMS developers who want to understand the RTEMS Source
     25Builder. New users who just want to build tools should follow :ref:`QuickStart`
     26in this manual. Users building a binary tool set for release can read the
     27"Installing and Tar Files". Users wanting to run and test bleeding edge tools
     28or packages, or wanting update or extend the RSB's configuration can read the
     29remaining sections.
    1830
    1931Embedded development typically uses cross-compiling tool chains, debuggers, and
     
    2234used outside of the RTEMS project and we welcome this.
    2335
    24 The RTEMS Source Builder is typically used to build a set of tools or a **build
    25 set**. A **build set** is a collection of packages and a package is a specific
    26 tool, for example GCC or GDB, or library. The RTEMS Source Builder attempts to
    27 support any host environment that runs Python and you can build the package
    28 on. The RSB is not some sort of magic that can take any piece of source code
    29 and make it build. Someone at some point in time has figured out how to build
    30 that package from source and taught this tool.
     36The RTEMS Source Builder is typically used to build a set of packages or a
     37**build set**. A **build set** is a collection of packages and a package is a
     38specific tool, for example GCC, GDB, or library of code and a single **build
     39set** can build them all in a single command. The RTEMS Source Builder
     40attempts to support any host environment that runs Python and you can build
     41the package on. The RSB is not some sort of magic that can take any piece of
     42source code and make it build. Someone at some point in time has figured out
     43how to build that package from source and taught this tool.
    3144
    32 The RTEMS Source Builder has been tested on:
     45.. sidebar:: Setting up your Host
     46
     47   See :ref:`QuickStartHost` for details on setting up hosts.
     48
     49The RTEMS Source Builder is known to work on:
    3350
    3451- ArchLinux
     
    4158- FreeBSD
    4259- NetBSD
     60- Solaris
    4361- MacOS
    4462- Windows
    45 
    46 .. topic:: Setting up your Host
    47 
    48    See :ref:`QuickStartHost` for details on setting up hosts.
    4963
    5064The RTEMS Source Builder has two types of configuration data. The first is the
     
    5367basic GNU tool set is Binutils, GCC, and GDB and is the typical base suite of
    5468tools you need for an embedded cross-development type project. The second type
    55 of configuration data is the configuration files and they define how a package
     69of configuration data are the configuration files and they define how a package
    5670is built. Configuration files are scripts loosely based on the RPM spec file
    5771format and they detail the steps needed to build a package. The steps are
     
    6781a problem please ask on our :r:list:`devel`.
    6882
    69 .. comment: TBD: The section "Installing and Tar Files" does not exist.
    70 
    71 This documentation caters for a range of users from new to experienced RTEMS
    72 developers who want to understand the RTEMS Source Builder. New users
    73 who just want to build tools should follow the Quick Start section in
    74 the User's Guide.  Users building a binary tool set for release can
    75 read the "Installing and Tar Files". Users wanting to run and test
    76 bleeding edge tools or packages, or wanting update or extend the RSB's
    77 configuration can read the remaining sections.
    78 
    7983.. topic:: Bug Reporting
    8084
     
    8488.. toctree::
    8589
    86     why-build-from-source.rst
    87     project-sets
    88     cross-canadian-cross
    89     third-party-packages
    90     configuration
    91     commands
    92     deployment
    93     bug-reporting
    94     history
     90   why-build-from-source.rst
     91   project-sets
     92   cross-canadian-cross
     93   third-party-packages
     94   configuration
     95   commands
     96   deployment
     97   bug-reporting
     98   history
  • user/rsb/project-sets.rst

    r6185f6e rbb47f89  
    88The RTEMS Source Builder supports project configurations. Project
    99configurations can be public or private and can be contained in the RTEMS
    10 Source Builder project if suitable, other projects they use the RTEMS Source
    11 Builder or privately on your local file system.
     10Source Builder project if suitable.
    1211
    1312The configuration file loader searches the macro ``_configdir`` and by default
    14 this is set to ``%{_topdir}/config:%{_sbdir}/config`` where ``_topdir`` is the
    15 your current working direct, in other words the directory you invoke the RTEMS
    16 Source Builder command in, and ``_sbdir`` is the directory where the RTEMS
    17 Source Builder command resides. Therefore the ``config`` directory under each
    18 of these is searched so all you need to do is create a ``config`` in your
    19 project and add your configuration files. They do not need to be under the
    20 RTEMS Source Builder source tree. Public projects are included in the main
    21 RTEMS Source Builder such as RTEMS.
    22 
    23 You can also add your own ``patches`` directory next to your ``config``
    24 directory as the ``%patch`` command searches the ``_patchdir`` macro variable
    25 and it is by default set to ``%{_topdir}/patches:%{_sbdir}/patches``.
     13this is set to ``%{_topdir}/config:%{_sbdir}/config`` where ``_topdir`` is your
     14current working directory, or the directory you invoke the RTEMS Source Builder
     15command in. The macro ``_sbdir`` is the directory where the RTEMS Source
     16Builder command resides. Therefore the ``config`` directory under each of these
     17is searched so all you need to do is create a ``config`` in your project and
     18add your configuration files. They do not need to be under the RTEMS Source
     19Builder source tree. Public projects are included in the main RTEMS Source
     20Builder such as RTEMS.
     21
     22You can add your own ``patches`` directory next to your ``config`` directory as
     23the ``%patch`` command searches the ``_patchdir`` macro variable and it is by
     24default set to ``%{_topdir}/patches:%{_sbdir}/patches``.
    2625
    2726The ``source-builder/config`` directory provides generic scripts for building
     
    3938^^^^^^^^^^
    4039
    41 The RSB contains a 'bare' configuration tree and you can use this to add
     40The RSB contains a ``bare`` configuration tree and you can use this to add
    4241packages you use on the hosts. For example 'qemu' is supported on a range of
    4342hosts. RTEMS tools live in the ``rtems/config`` directory tree. RTEMS packages
     
    8281^^^^^
    8382
    84 The RTEMS Configurations found in the ``rtems`` directory. The configurations
    85 are grouped by RTEMS version. In RTEMS the tools are specific to a specific
    86 version because of variations between Newlib and RTEMS. Restructuring in RTEMS
    87 and Newlib sometimes moves *libc* functionality between these two parts and
    88 this makes existing tools incompatible with RTEMS.
     83The RTEMS Configurations are found in the ``rtems`` directory. The
     84configurations are grouped by RTEMS version and a release normally only
     85contains the configurations for that release.. In RTEMS the tools are specific
     86to a specific version because of variations between Newlib and
     87RTEMS. Restructuring in RTEMS and Newlib sometimes moves *libc* functionality
     88between these two parts and this makes existing tools incompatible with RTEMS.
    8989
    9090RTEMS allows architectures to have different tool versions and patches. The
     
    9292common stable version of all the packages. An architecture may require a recent
    9393GCC because an existing bug has been fixed, however the more recent version may
    94 have a bug in other architecture. Architecture specific patches should be
    95 limited to the architecture it relates to. The patch may fix a problem on the
    96 effect architecture however it could introduce a problem in another
    97 architecture. Limit exposure limits any possible crosstalk between
     94have a bug in other architecture. Architecture specific patches should only be
     95appliaed when build the related architecture. A patch may fix a problem on one
     96architecture however it could introduce a problem in another
     97architecture. Limiting exposure limits any possible crosstalk between
    9898architectures.
    9999
    100 If you are building a released version of RTEMS the release RTEMS tar file will
    101 be downloaded and built as part of the build process. If you are building a
    102 tool set for use with the development branch of RTEMS, the development branch
    103 will be cloned directly from the RTEMS GIT repository and built.
    104 
    105 When building RTEMS within the RTEMS Source Builder it needs a suitable working
    106 ``autoconf`` and ``automake``. These packages need to built and installed in their
    107 prefix in order for them to work. The RTEMS Source Builder installs all
    108 packages only after they have been built so if you host does not have a
    109 recent enough version of ``autoconf`` and ``automake`` you first need to build them
    110 and install them then build your tool set. The commands are:
    111 
    112 .. code-block:: none
    113 
    114     $ ../source-builder/sb-set-builder --log=l-4.11-at.txt \
    115        --prefix=$HOME/development/rtems/4.11 4.11/rtems-autotools
    116     $ export PATH=~/development/rtems/4.11/bin:$PATH    <1>
    117     $ ../source-builder/sb-set-builder --log=l-4.11-sparc.txt \
    118        --prefix=$HOME/development/rtems/4.11 4.11/rtems-sparc
    119 
    120 .. topic:: Items:
    121 
    122   1. Setting the path.
    123 
    124 If this is your first time building the tools and RTEMS it pays to add the
    125 ``--dry-run`` option. This will run through all the configuration files and if
    126 any checks fail you will see this quickly rather than waiting for until the
    127 build fails a check.
    128 
    129 To build snapshots for testing purposes you use the available macro maps
    130 passing them on the command line using the ``--macros`` option. For RTEMS these
    131 are held in ``config/snapshots`` directory. The following builds *newlib* from
    132 CVS:
    133 
    134 .. code-block:: none
    135 
    136     $ ../source-builder/sb-set-builder --log=l-4.11-sparc.txt \
    137        --prefix=$HOME/development/rtems/4.11 \
    138        --macros=snapshots/newlib-head.mc \
    139        4.11/rtems-sparc
    140 
    141 and the following uses the version control heads for ``binutils``, ``gcc``,
    142 ``newlib``, ``gdb`` and *RTEMS*:
    143 
    144 .. code-block:: none
    145 
    146     $ ../source-builder/sb-set-builder --log=l-heads-sparc.txt \
    147        --prefix=$HOME/development/rtems/4.11-head \
    148        --macros=snapshots/binutils-gcc-newlib-gdb-head.mc \
    149        4.11/rtems-sparc
     100If you have a configuation issue try adding the ``--dry-run`` option. This will
     101run through all the configuration files and if any checks fail you will see
     102this quickly rather than waiting for until the build fails a check.
    150103
    151104Following features can be enabled/disabled via the command line for the RTEMS
    152105build sets:
    153106
    154 ``--without-rtems``
    155   Do not build RTEMS when building an RTEMS build set.
    156 
    157107``--without-cxx``
    158108  Do not build a C++ compiler.
     
    166116``--with-objc``
    167117  Attempt to build a C++ compiler.
     118
     119The RSB provides build sets for some BSPs. These build sets will build:
     120
     121- Compiler, linker, debugger and RTEMS Tools.
     122
     123- RTEMS Kernel for the BSP
     124
     125- Optionally LibBSD if supported by the BSP.
     126
     127- Third party packages if supported by the BSP.
    168128
    169129Patches
     
    184144can be added.
    185145
    186 Patches for packages developed by the RTEMS project can be placed in the RTEMS
    187 Tools Git repository. The ``tools`` directory in the repository has various
    188 places a patch can live. The tree is broken down in RTEMS releases and then
    189 tools within that release. If the package is not specific to any release the
    190 patch can be added closer to the top under the package's name. Patches to fix
    191 specific tool related issues for a specific architecture should be grouped
    192 under the specific architecture and only applied when building that
    193 architecture avoiding a patch breaking an uneffected architecture.
    194 
    195 Patches in the RTEMS Tools repository need to be submitted to the upstream
    196 project. It should not be a clearing house for patches that will not be
    197 accepted upstream.
     146Referenced patches should be placed in a location that is easy to access and
     147download with a stable URL. We recommend attaching a patch to an RTEMS ticket
     148in it's bug reporting system or posting to a mailing list with online archives.
     149
     150RTEMS's former practice of placing patches in the RTEMS Tools Git repository
     151has been stopped.
    198152
    199153Patches are added to a component's name and in the ``%prep:`` section the
    200 patches can be set up, meaning they are applied to source. The patches
    201 are applied in the order they are added. If there is a dependency make
    202 sure you order the patches correctly when you add them. You can add any
    203 number of patches and the RSB will handle them efficently.
     154patches can be set up, meaning they are applied to source. The patches are
     155applied in the order they are added. If there is a dependency make sure you
     156order the patches correctly when you add them. You can add any number of
     157patches and the RSB will handle them efficently.
    204158
    205159Patches can have options. These are added before the patch URL. If no options
     
    227181.. code-block:: spec
    228182
    229     %hash md5 <1> gdb-sim-lm32uart.diff <2> 77d070878112783292461bd6e7db17fb <3>
    230 
    231 .. topic:: Items:
    232 
    233   1. The type of checksum, in the case an MD5 hash.
     183    %hash sha512 <1> gdb-sim-lm32uart.diff <2> 77d07087 ... e7db17fb <3>
     184
     185.. topic:: Items:
     186
     187  1. The type of checksum, in the case an SHA512 hash.
    234188
    235189  2. The patch file the checksum is for.
    236190
    237   3. The MD5 hash.
     191  3. The SHA512 hash.
    238192
    239193The patches are applied when a patch ``setup`` command is issued in the
  • user/rsb/third-party-packages.rst

    r6185f6e rbb47f89  
    33.. Copyright (C) 2012, 2016 Chris Johns <chrisj@rtems.org>
    44
    5 RTEMS Third-Party Packages
    6 --------------------------
     5Third-Party Packages
     6--------------------
    77
    88This section describes how to build and add an RTEMS third-party package to the
     
    1010
    1111A third-party package is a library or software package built to run on RTEMS,
    12 examples are NTP, Net-Snmp, libjpeg or Python. These pieces of software can be
    13 used to help build RTEMS applications. The package is built for a specific
    14 BSP and so requires a working RTEMS tool chain and an installed RTEMS Board
    15 Support Package (BSP).
    16 
    17 The RSB support for building third-party packages is based around the *pkconfig*
    18 files (PC) installed with the BSP. The pkgconfig support in RTEMS is considered
    19 experimental and can have some issues for some BSPs. This issue is rooted deep
    20 in the RTEMS build system. If you have any issues with this support please ask
    21 on the RTEMS developers mailing list.
     12examples are Curl, NTP, Net-Snmp, libjpeg and more. These pieces of software
     13can be used to help build RTEMS applications. The package is built for a
     14specific BSP and so requires a working RTEMS tool chain, an installed RTEMS
     15Board Support Package (BSP), and a network stack if the package uses
     16networking resources.
     17
     18.. sidebar:: Help
     19
     20   If you have any issues using, building or adding third party packages please
     21   ask on the RTEMS users mailing list.
     22
     23
     24The RSB support for building third-party packages is based around the
     25*pkconfig* files (PC) installed with the BSP. The pkgconfig support in RTEMS is
     26considered experimental and can have some issues for some BSPs. This issue is
     27rooted deep in the RTEMS build system.
    2228
    2329Vertical Integration
     
    2632The RSB supports horizontal integration with support for multiple
    2733architectures. Adding packages to the RSB as libraries is vertical
    28 integration. Building the GCC tool chain requires you build an assembler before
    29 you build a compiler. The same can be done for third-party libraries, you can
    30 crate build sets that stack library dependences vertically to create a *stack*.
     34integration. Building the GCC tool chain requires you build an assembler
     35before you build a compiler. The same can be done for third-party libraries,
     36you can create build sets that stack library dependences vertically to create
     37a *stack*.
    3138
    3239Building
     
    3542To build a package you need to have a suitable RTEMS tool chain and RTEMS BSP
    3643installed. The set builder command line requires you provide the tools path,
    37 the RTEMS host, and the prefix path to the installed RTEMS BSP. The prefix
    38 needs to be the same as the prefix used to build RTEMS.
    39 
    40 To build Net-SNMP the command is:
     44the RTEMS architecture (host), the BSP, and the prefix path used to the
     45install RTEMS BSP.
     46
     47The RSB prefix option (``--prefix``) provided when building a package is the
     48path to:
     49
     50#. The tools, RTEMS kernel and any dependent libraries such as LibBSD. The
     51   package will be installed into the prefix path. This build configuration can
     52   be used to make a complete set of development tools and libraries for a
     53   project or product under a single path.
     54
     55#. The RTEMS kernel and any dependent libraries such as LibBSD. The tools path
     56   needs to be in the environment path (not recommended) or provided to the set
     57   builder command by the ``--with-tools`` option. The package will be
     58   installed into the prefix path. This build configuration can be used when
     59   you have a set of tools used with a number of RTEMS BSPs. The tools can be
     60   shared between the different BSPs.
     61
     62#. The path the package is installed into. The tools path needs to be in the
     63   environment path (not recommended) or provided to the set builder command
     64   using the ``--with-tools`` option. The path to the RTEMS kernel and any
     65   dependent libraries such as LibBSD needs to be supplied to the set builder
     66   command using the ``--with-rtems`` option. This build configuration can be
     67   used when you have a set of libraries you are testing with a changing RTEMS
     68   kernel. Becareful using this configuration as changes in RTEMS interfaces
     69   may require rebuilding these packages.
     70
     71The set builder command option ``--host`` is used to provide the RTEMS
     72architecture the package is being built for. For example ``--host=arm-rtems5``
     73is used for any ARM BSP.
     74
     75The set builder command option ``--with-rtems-bsp`` is the RTEMS BSP the
     76package is being built for. The BSP is searched for under the path provided by
     77the command option ``--with-rtems`` and if this option is not provided the
     78provided prefix is searched.
     79
     80The following example builds and installs the Curl networking package for the
     81ARM BeagleBone Black BSP installing it into the same path the tools, RTEMS
     82kernel and LibBSD are installed in.
    4183
    4284.. code-block:: none
    4385
    44     $ cd rtems-source-builder/rtems
    45     $ ../source-builder/sb-set-builder --log=log_sis_net_snmp \
    46         --prefix=$HOME/development/rtems/bsps/4.11 \
    47         --with-tools=$HOME/development/rtems/4.11 \
    48         --host=sparc-rtems4.11 --with-rtems-bsp=erc32 4.11/net-mgmt/net-snmp
    49     RTEMS Source Builder - Set Builder, v0.3.0
    50     Build Set: 4.11/net-mgmt/net-snmp
    51     config: net-mgmt/net-snmp-5.7.2.1-1.cfg
    52     package: net-snmp-5.7.2.1-sparc-rtems4.11-1
    53     building: net-snmp-5.7.2.1-sparc-rtems4.11-1
    54     installing: net-snmp-5.7.2.1-sparc-rtems4.11-1 -> /Users/chris/development/rtems/bsps/4.11
    55     cleaning: net-snmp-5.7.2.1-sparc-rtems4.11-1
    56     Build Set: Time 0:01:10.651926
     86 $ ../source-builder/sb-set-builder --prefix=$HOME/development/cs/rtems/5 \
     87       --log=curl.txt --host=arm-rtems5 --with-rtems-bsp=beagleboneblack ftp/curl
     88 RTEMS Source Builder - Set Builder, 5 (2bdae1f169e4)
     89 Build Set: ftp/curl
     90 config: ftp/curl-7.65.1-1.cfg
     91 package: curl-v7.65.1-arm-rtems5-1
     92 download: https://curl.haxx.se/download/curl-7.65.1.tar.xz -> sources/curl-7.65.1.tar.xz
     93 downloading: sources/curl-7.65.1.tar.xz - 2.3MB of 2.3MB (100%)
     94 building: curl-v7.65.1-arm-rtems5-1
     95 sizes: curl-v7.65.1-arm-rtems5-1: 87.055MB (installed: 2.238MB)
     96 cleaning: curl-v7.65.1-arm-rtems5-1
     97 reporting: ftp/curl-7.65.1-1.cfg -> curl-v7.65.1-arm-rtems5-1.txt
     98 reporting: ftp/curl-7.65.1-1.cfg -> curl-v7.65.1-arm-rtems5-1.xml
     99 installing: curl-v7.65.1-arm-rtems5-1 -> /Users/chris/development/cs/rtems/5
     100 cleaning: curl-v7.65.1-arm-rtems5-1
     101 Build Set: Time 0:01:10.006872
    57102
    58103Adding
    59104^^^^^^
    60105
    61 Adding a package requires you first build it manually by downloading the source
    62 for the package and building it for RTEMS using the command line of a standard
    63 shell. If the package has not been ported to RTEMS you will need to port it and
    64 this may require you asking questions on the package's user or development
    65 support lists as well as RTEMS's developers list. Your porting effort may end
    66 up with a patch. RTEMS requires a patch be submitted upstream to the project's
    67 community as well as RTEMS so it can be added to the RTEMS Tools git
    68 repository. A patch in the RTEMS Tools git reposiitory can then be referenced
    69 by an RSB configuration file.
    70 
    71 A package may create executables, for example NTP normally creates executables
    72 such as ``ntdp``, ``ntpupdate``, or ``ntpdc``. These executables can be useful
    73 when testing the package however they are of limited use by RTEMS users because
    74 they cannot be directly linked into a user application. Users need to link to
    75 the functions in these executables or even the executable as a function placed
    76 in libraries. If the package does not export the code in a suitable manner
    77 please contact the project's commuinity and see if you can work them to provide
    78 a way for the code to be exported. This may be difficult because exporting
    79 internal headers and functions opens the project up to API compatibility issues
    80 they did not have before. In the simplest case attempting to get the code into
    81 a static library with a single call entry point exported in a header would give
    82 RTEMS user's access to the package's main functionality.
    83 
    84 A package requires 3 files to be created:
    85 
    86 - The first file is the RTEMS build set file and it resides in the
    87   ``rtems/config/%{rtems_version}`` path in a directory tree based on the
    88   FreeBSD ports collection. For the NTP package and RTEMS 4.11 this is
    89   ``rtems/config/4.11/net/ntp.bset``. If you do not know the FreeBSD port path
    90   for the package you are adding please ask. The build set file references a
    91   specific configuration file therefore linking the RTEMS version to a specific
    92   version of the package you are adding. Updating the package to a new version
    93   requires changing the build set to the new configuration file.
    94 
    95 - The second file is an RTEMS version specific configuration file and it
    96   includes the RSB RTEMS BSP support. These configuration files reside in the
    97   ``rtems/config`` tree again under the FreeBSD port's path name. For example
    98   the NTP package is found in the ``net`` directory of the FreeBSD ports tree
    99   so the NTP configuration path is ``rtems/config/net/ntp-4.2.6p5-1.cfg`` for
    100   that specific version. The configuration file name typically provides version
    101   specific references and the RTEMS build set file references a specific
    102   version. This configuration file references the build configuration file held
    103   in the common configuration file tree.
    104 
    105 - The build configuration. This is a common script that builds the package. It
    106   resides in the ``source-builder/config`` directory and typically has the
    107   packages's name with the major version number. If the build script does not
    108   change for each major version number a *common* base script can be created
    109   and included by each major version configuration script. The *gcc* compiler
    110   configuration is an example. This approach lets you branch a version if
    111   something changes that is not backwards compatible. It is important to keep
    112   existing versions building. The build configuration should be able to build a
    113   package for the build host as well as RTEMS as the RSB abstracts the RTEMS
    114   specific parts. See :ref:`Configuration` for more details.
     106Adding a package requires you first build it manually by downloading the
     107source for the package and building it for RTEMS using the command line of a
     108standard shell. If the package has not been ported to RTEMS you will need to
     109port it and this may require asking questions on the package's user or
     110development support lists as well as RTEMS's developers list. Your porting
     111effort may end up with a patch. RTEMS requires a patch be submitted upstream
     112to the project's community as well as RTEMS. The RTEMS submission is best as a
     113patch attached to ticket in Trac. A patch attached to a ticket can be
     114referenced by an RSB configuration file and used in a build.
     115
     116.. sidebar:: Patches in Trac
     117
     118   Attaching patches for packages to Trac tickets provides an easy to reference
     119   URL the RSB can fetch. The patch URL does not change across RTEMS versions
     120   and it does not depend on the state or layout of a git repo.
     121
     122
     123A package may create executables, for example Curl normally creates an
     124executable called ``curl`` how ever it will probailty not run because the
     125needed RTEMS configuration is not suitable. If found the RSB automatically
     126adds the RTEMS library ``librtemsdefaultconfig.a`` to the ``LIBS`` variable
     127used to link executables. This library provides a limited configuraiton
     128suitable for linking an executable however it is not a set up that allows the
     129resulting executable to run correctly. As a result it is best not to install
     130these executables.
     131
     132A custom RTEMS patch to an executate's source code can turn it into a function
     133that can be called by the RTEMS shell. Users can call the function in their
     134executables simulating the running of the package's command. If the package
     135does not export the code in a suitable manner please contact the project's
     136commuinity and see if you can work with them to provide a way for the code to
     137be exported. This may be difficult because exporting internal headers and
     138functions opens the project up to API compatibility issues they did not have
     139before. In the simplest case attempting to get the code into a static library
     140with a single call entry point exported in a header would give RTEMS user's
     141access to the package's main functionality.
     142
     143A package requires at least three (3) files to be created:
     144
     145  Published Package Name:
     146    The first file is the RTEMS build set file and it resides under the
     147    ``rtems/config`` path in a directory tree based on the FreeBSD ports
     148    collection. For the Curl package and RTEMS 5 this is
     149    ``rtems/config/ftp/curl.bset``. If you do not know the FreeBSD port path
     150    for the package you are adding please ask. The build set file references a
     151    specific configuration file therefore linking the RTEMS version to a
     152    specific version of the package you are adding. Updating the package to a
     153    new version requires changing the build set to the new configuration file.
     154
     155  Package Version Configuration File:
     156    The second file is an RTEMS version specific configuration file and it
     157    includes the RSB RTEMS BSP support. These configuration files reside in
     158    the ``rtems/config`` tree and under the FreeBSD port's path name. For
     159    example the Curl package is found in the ``ftp`` directory of the FreeBSD
     160    ports tree so the Curl configuration path is
     161    ``rtems/config/ftp/curl-7.65.1-1.cfg`` for that specific version. The
     162    configuration file name typically provides version specific references and
     163    the RTEMS build set file references a specific version. This configuration
     164    file references the build configuration file held in the common
     165    configuration file tree. An SHA512 hash is required to verify the source
     166    package that is downloaded.
     167
     168  Build Configuration File:
     169    The build configuration. This is a common script that builds the
     170    package. It resides in the ``source-builder/config`` directory and
     171    typically has the packages's name with the major version number. If the
     172    build script does not change for each major version number a *common* base
     173    script can be created and included by each major version configuration
     174    script. The *gcc* compiler configuration is an example. This approach lets
     175    you branch a version if something changes that is not backwards
     176    compatible. It is important to keep existing versions building. The build
     177    configuration should be able to build a package for the build host as well
     178    as RTEMS as the RSB abstracts the RTEMS specific parts. See
     179    :ref:`Configuration` for more details.
     180
     181Host and Build Flags
     182^^^^^^^^^^^^^^^^^^^^
     183
     184A package's build is controlled by setting the compiler names and flags that
     185are used when building. The RSB provides a macro called
     186``%{host_build_flags}`` to define these flags for you. Use this macro in the
     187```%build`` section of your config script file to define the set up needed to
     188build a native package or to cross-compile to a specific host such as RTEMS
     189. The typical ``%build`` section is:
     190
     191.. code-block:: spec
     192
     193 %build
     194   build_top=$(pwd)
     195
     196   %{build_directory}
     197
     198   mkdir -p ${build_dir}
     199   cd ${build_dir}
     200
     201   %{host_build_flags}
     202
     203   ../${source_dir_curl}/configure \
     204     --host=%{_host} \
     205     --prefix=%{_prefix} \
     206     --bindir=%{_bindir} \
     207     --exec_prefix=%{_exec_prefix} \
     208     --includedir=%{_includedir} \
     209     --libdir=%{_libdir} \
     210     --libexecdir=%{_libexecdir} \
     211     --mandir=%{_mandir} \
     212     --infodir=%{_infodir} \
     213     --datadir=%{_datadir}
     214
     215   %{__make} %{?_smp_mflags} all
     216
     217   cd ${build_top}
     218
     219The ``%{host_build_flags}`` checks if the build is native for the development
     220host or a cross-compile build.
     221
     222For a cross-complication build the flags are:
     223
     224``CC``, ``CC_FOR_HOST``:
     225 The C compiler used to build the package. For an RTEMS build this is the
     226 RTEMS C compiler. For example the ARM architecture and RTEMS 5 the value is
     227 set to ``arm-rtems5-gcc``.
     228
     229``CXX``, ``CXX_FOR_HOST``:
     230 The C++ compiler used to build the package. For an RTEMS build this is the
     231 RTEMS C++ compiler. For example the ARM architecture and RTEMS 5 the value is
     232 set to ``arm-rtems5-g++``.
     233
     234``CPPFLAGS``, ``CPPFLAGS_FOR_HOST``:
     235 The C compiler preprocessor flags used to build the package. Set any include
     236 paths in this variable as some configure scripts will warns you if include
     237 paths are set in the ``CFLAGS``.
     238
     239``CFLAGS``, ``CFLAGS_FOR_HOST``:
     240 The C compiler flags used when running the C compiler. Set any include paths
     241 in the ``CPPFLAGS`` variable as some configure scripts will warn you if
     242 include paths in this variable.
     243
     244``CXXFLAGS``, ``CXXFLAGS_FOR_HOST``:
     245 The C++ compiler flags used when running the C++ compiler. Set any include
     246 paths in the ``CPPFLAGS`` variable as some configure scripts will warn you if
     247 include paths in this variable.
     248
     249``LDFLAGS``, ``LDFLAGS_FOR_HOST``:
     250 The linker flags used whne link package executables. The C or C++ compiler
     251 is used to run the linker.
     252
     253``LIBS``, ``LIBS_FOR_HOST``:
     254 A list of libraries passed to the linker when linking an executable.
     255
     256``CC_FOR_BUILD``:
     257 The native C compiler.
     258
     259``CXX_FOR_BUILD``:
     260 The native C++ compiler.
     261
     262``CPPFLAGS_FOR_BUILD``:
     263 The C preprocessor flags used when preprocessoring a native C source file.
     264
     265``CFLAGS_FOR_BUILD``:
     266 The native C compiler flags used when running the native C compiler.
     267
     268``CXXFLAGS_FOR_BUILD``:
     269 The native C++ compiler flags used when running the native C++ compiler.
     270
     271``LDFLAGS_FOR_BUILD``:
     272 The native linker flags used when linking a native executable.
     273
     274``LIBS_FOR_BUILD``:
     275 The native libraries used to when linking a native executable.
     276
     277For a native build the flags are:
     278
     279``CC``, ``CC_FOR_BUILD``:
     280 The native C compiler.
     281
     282``CXX``, ``CXX_FOR_BUILD``:
     283 The native C++ compiler.
     284
     285``CPPFLAGS``, ``CPPFLAGS_FOR_BUILD``:
     286 The C preprocessor flags used when preprocessoring a native C source file.
     287
     288``CFLAGS``, ``CFLAGS_FOR_BUILD``:
     289 The native C compiler flags used when running the native C compiler.
     290
     291``CXXFLAGS``, ``CXXFLAGS_FOR_BUILD``:
     292 The native C++ compiler flags used when running the native C++ compiler.
     293
     294``LDFLAGS``, ``LDFLAGS_FOR_BUILD``:
     295 The native linker flags used when linking a native executable.
     296
     297``LIBS``, ``LIBS_FOR_BUILD``:
     298 The native libraries used to when linking a native executable.
    115299
    116300BSP Support
    117301^^^^^^^^^^^
    118302
    119 The RSB provides support to help build packages for RTEMS. RTEMS applications
    120 can be viewed as statically linked executables operating in a single address
     303The RSB provides support to build packages for RTEMS. RTEMS applications can
     304be viewed as statically linked executables operating in a single address
    121305space. As a result only the static libraries a package builds are required and
    122 these libraries need to be ABI compatible with the RTEMS kernel and application
    123 code meaning compiler ABI flags cannot be mixed when building code. The 3rd
    124 party package need to use the same compiler flags as the BSP used to build
    125 RTEMS.
     306these libraries need to be ABI compatible with the RTEMS kernel and
     307application code. This means the compiler ABI flags used to build all the code
     308in the executable must be the same. A 3rd party package must use the same
     309compiler flags as the BSP used to build RTEMS.
    126310
    127311.. note::
     
    135319The RSB provides the configuration file ``rtems/config/rtems-bsp.cfg`` to
    136320support building third-party packages and you need to include this file in your
    137 RTEMS version specific configuration file. For example the Net-SNMP
    138 configuration file ``rtems/config/net-mgmt/net-snmp-5.7.2.1-1.cfg``:
    139 
    140 .. code-block:: spec
    141 
    142     #
    143     # NetSNMP 5.7.2.1
    144     #
    145     %if %{release} == %{nil}
    146      %define release 1    <1>
    147     %endif
    148 
    149     %include %{_configdir}/rtems-bsp.cfg   <2>
    150 
    151     #
    152     # NetSNMP Version
    153     #
    154     %define net_snmp_version 5.7.2.1   <3>
    155 
    156     #
    157     # We need some special flags to build this version.
    158     #
    159     %define net_snmp_cflags <4> -DNETSNMP_CAN_USE_SYSCTL=1 -DARP_SCAN_FOUR_ARGUMENTS=1 -DINP_IPV6=0
    160 
    161     #
    162     # Patch for RTEMS support.
    163     #
    164     %patch add net-snmp %{rtems_git_tools}/net-snmp/rtems-net-snmp-5.7.2.1-20140623.patch <5>
    165 
    166     #
    167     # NetSNMP Build configuration
    168     #
    169     %include %{_configdir}/net-snmp-5-1.cfg   <6>
     321RTEMS version specific configuration file. For example the Curl configuration
     322file ``rtems/config/curl/curl-7.65.1-1.cfg``:
     323
     324.. code-block:: spec
     325
     326 #
     327 # Curl 7.65.1
     328 #
     329
     330 %if %{release} == %{nil}
     331  %define release 1  <1>
     332 %endif
     333
     334 %include %{_configdir}/rtems-bsp.cfg   <2>
     335
     336 #
     337 # Curl Version
     338 #
     339 %define curl_version 7.65.1   <3>
     340
     341 %hash sha512 curl-%{curl_version}.tar.xz aba2d979a...72b6ac55df4   <4>
     342
     343 #
     344 # Curl Build configuration
     345 #
     346 %include %{_configdir}/curl-1.cfg <5>
    170347
    171348.. topic:: Items:
     
    175352  2. Include the RSB RTEMS BSP support.
    176353
    177   3. The Net-SNMP package's version.
    178 
    179   4. Add specific ``CFLAGS`` to the build process. See the
    180      ``net-snmp-5.7.2.1-1.cfg`` for details.
    181 
    182   5. The RTEMS Net-SNMP patch downloaded from the RTEMS Tools git repo.
    183 
    184   6. The Net-SNMP standard build configuration.
     354  3. The Curl package's version.
     355
     356  4. The SHA512 hash for the source file. The hash here has been shortened.
     357
     358  5. The Curl standard build configuration.
    185359
    186360The RSB RTEMS BSP support file ``rtems/config/rtems-bsp.cfg`` checks to make
    187 sure standard command line options are provided. These include ``--host`` and
    188 ``--with-rtems-bsp``. If the ``--with-tools`` command line option is not given
    189 the ``${_prefix}`` is used:
    190 
    191 .. code-block:: spec
    192 
    193     %if %{_host} == %{nil} <1>
    194      %error No RTEMS target specified: --host=host
    195     %endif
    196 
    197     %ifn %{defined with_rtems_bsp} <2>
    198      %error No RTEMS BSP specified: --with-rtems-bsp=bsp
    199     %endif
    200 
    201     %ifn %{defined with_tools} <3>
    202      %define with_tools %{_prefix}
    203     %endif
    204 
    205     #
    206     # Set the path to the tools.
    207     #
    208     %{path prepend %{with_tools}/bin} <4>
    209 
    210 .. topic:: Items:
    211 
    212   1. Check the host has been set.
    213 
    214   2. Check a BSP has been specified.
    215 
    216   3. If no tools path has been provided assume they are under the
    217      ``%{_prefix}``.
    218 
    219   4. Add the tools ``bin`` path to the system path.
    220 
    221 RTEMS exports the build flags used in *pkgconfig* (.pc) files and the RSB can
    222 read and manage them even when there is no pkgconfig support installed on your
    223 build machine. Using this support we can obtain a BSP's configuration and set
    224 some standard macros variables (``rtems/config/rtems-bsp.cfg``):
     361sure the required RSB command line options are provided. These include
     362``--host`` and ``--with-rtems-bsp``. If the ``--with-tools`` command line
     363option is not given the ``${_prefix}`` is used as the path to the tools. If
     364the ``--with-rtems`` command line option is not given the ``${_prefix}`` is
     365used as the path to the installed RTEMS BSP.
     366
     367.. note::
     368
     369   The RTEMS BSP and any dependent 3rd party packages must be installed to be
     370   seen as available. A path to the location the BSP has been built will not
     371   work.
     372
     373The first check is to make sure a target is not specified. This is only used
     374for Canadian cross-compilication builds and currently there is no support for
     375RTEMS third party packages to build that way:
     376
     377.. code-block:: spec
     378
     379 #
     380 # The target is used by compilers or Cxc builds.
     381 #
     382 %if %{_target} != %{nil}
     383  %error RTEMS BSP builds use --host and not --target
     384 %endif
     385
     386A host is required using the ``--host`` option:
     387
     388.. code-block:: spec
     389
     390 #
     391 # We need a host from the user to specifiy the RTEMS architecture and major
     392 # version.
     393 #
     394 %if %{_host} == %{nil} && %{rtems_bsp_error} <1>
     395  %error No RTEMS host or BSP specified: --host=<arch>-rtems<ver>
     396 %endif
     397
     398An RTEMS BSP is required using the ``--with-bsp`` option:
     399
     400.. code-block:: spec
     401
     402 #
     403 # We need a BSP from the user.
     404 #
     405 %ifn %{defined with_rtems_bsp}
     406  %if %{rtems_bsp_error}
     407   %error No RTEMS BSP specified: --rtems-bsp=arch/bsp (or --with-rtems-bsp=bsp)
     408  %endif
     409  %define with_rtems_bsp sparc/erc32
     410 %endif
     411
     412Check if the ``--with-tools`` or ``--with-rtems`` options have been provided
     413and if they are not provided use the ``--prefix`` path:
     414
     415.. code-block:: spec
     416
     417 #
     418 # If no tools or RTEMS provided use the prefix.
     419 #
     420 %ifn %{defined with_tools}
     421  %define with_tools %{_prefix}
     422 %endif
     423
     424 %ifn %{defined with_rtems}
     425  %define with_rtems %{_prefix}
     426 %endif
     427
     428Add the tools path to the envnironment path:
     429
     430.. code-block:: spec
     431
     432 #
     433 # Set the path to the tools.
     434 #
     435 %{path prepend %{with_tools}/bin}
     436
     437RTEMS exports the build configuration in *pkgconfig* (.pc) files. The RSB can
     438read these files even when there is no ``pkgconfig`` support installed on your
     439development machine. The *pkgconfig* support provides a BSP's configuration and
     440the RSB uses it to set the followng RSB macros variables:
    225441
    226442.. code-block:: spec
     
    243459  1. Set the path to the BSP's pkgconfig file.
    244460
    245   2. Let pkgconfig know this is a cross-compile build.
    246 
    247   3. Filter flags such as warnings. Warning flags are specific to a package.
    248 
    249   4. Ask pkgconfig for the various items we require.
    250 
    251 The flags obtain by pkgconfig and given a ``rtems_bsp_`` prefix and we uses these
    252 to set the RSB host support CFLAGS, LDFLAGS and LIBS flags. When we build a 3rd
    253 party library your host computer is the _build_ machine and RTEMS is the _host_
    254 machine therefore we set the ``host`` variables
    255 (``rtems/config/rtems-bsp.cfg``):
     461  2. Let *pkgconfig* know this is a cross-compile build.
     462
     463  3. Filter flags such as warnings. Warning flags are specific to a package and
     464     RTEMS exports it's warnings flags in the BSP configuration settings.
     465
     466  4. Ask *pkgconfig* for the various settings we require.
     467
     468The flags obtained by *pkgconfig* and given a ``rtems_bsp`` prefix are used to
     469set the RTEMS host variables ``CFLAGS``, ``LDFLAGS`` and ``LIBS``. When we
     470build a third party library your host computer is the **build** machine and
     471RTEMS is the **host** machine therefore we set the ``host`` variables:
    256472
    257473.. code-block:: spec
     
    264480package. Packages by default consider the ``_prefix`` the base and install
    265481various files under this tree. The package you are building is specific to a
    266 BSP and so needs to install into the specific BSP path under the
    267 ``_prefix``. This allows more than BSP build of this package to be install
    268 under the same ``_prefix`` at the same time (``rtems/config/rtems-bsp.cfg``):
     482BSP and needs to install it's files into the RTEMS specific BSP path under the
     483``_prefix``. This allows more than BSP build of this package to be installed
     484under the same ``_prefix`` at the same time:
    269485
    270486.. code-block:: spec
     
    292508.. topic:: Items:
    293509
    294   1. The path to the BSP.
     510  1. The path to the installed BSP.
    295511
    296512When you configure a package you can reference these paths and the RSB will
    297 provide sensible default or in this case map them to the BSP
    298 (``source-builder/config/ntp-4-1.cfg``):
    299 
    300 .. code-block:: spec
    301 
    302       ../${source_dir_ntp}/configure \ <1>
     513provide sensible default or in this case map them to the BSP:
     514
     515.. code-block:: spec
     516
     517      ../${source_dir_curl}/configure \ <1>
    303518        --host=%{_host} \
    304519        --prefix=%{_prefix} \
     
    310525        --mandir=%{_mandir} \
    311526        --infodir=%{_infodir} \
    312         --datadir=%{_datadir} \
    313         --disable-ipv6 \
    314         --disable-HOPFPCI
     527        --datadir=%{_datadir}
    315528
    316529.. topic:: Items:
    317530
    318   1. The configure command for NTP.
    319 
    320 RTEMS BSP Configuration
    321 ^^^^^^^^^^^^^^^^^^^^^^^
    322 
    323 To build a package for RTEMS you need to build it with the matching BSP
    324 configuration. A BSP can be built with specific flags that require all code
    325 being used needs to be built with the same flags.
     531  1. The configure command for Curl.
     532
     533
     534BSP Configuration
     535^^^^^^^^^^^^^^^^^
     536
     537The following RSB macros are defined when building a package for RTEMS:
     538
     539.. note::
     540
     541    A complete list can be obtained by building with the ``--trace`` flag. The
     542    log will contain a listing of all macros before and after the configuration
     543    is loaded.
     544
     545``%{rtems_bsp}``:
     546 The name of the RTEMS BSP.
     547
     548``%{rtems_bsp_cc}``:
     549 The C compiler name for the RTEMS BSP.
     550
     551``%{rtems_bsp_cflags}``:
     552 The C compiler flags for the RTEMS BSP.
     553
     554``%{rtems_bsp_ccflags}``:
     555 The C++ compiler flags for the RTEMS BSP.
     556
     557``%{rtems_bsp_incpath}``:
     558 The include path to teh RTEMS BSP header files.
     559
     560``%{rtems_bsp_ldflags}``:
     561 The linker flags for the RTEMS BSP.
     562
     563``%{rtems_bsp_libs}``:
     564 The libraries used when linking an RTEMS BSP executable.
     565
     566``%{rtems_bsp_prefix}``:
     567 The prefix for the RTEMS BSP.
     568
     569``%{rtems-libbsd}``:
     570 The variable is set to ``found`` if LibBSD is available.
     571
     572``%{rtems-defaultconfig}``:
     573 The path of the RSB helper script to locate find header files or libraries.
     574
     575``%{_host}``
     576 The host triplet passed on the command line to the set builder using the
     577 ``--host`` options. This is the RTEMS architecture and version. For example
     578 ``arm-rtems5``.
     579
     580``%{host_cflags}``:
     581 The BSP ``CFLAGS`` returned by ``pkgconfig``.
     582
     583``%{host_cxxflags}``:
     584 The BSP ``CXXFLAGS`` returned by ``pkgconfig``.
     585
     586``%{host_includes}``:
     587 The BSP include paths returned by ``pkgconfig``.
     588
     589``%{host_ldflags}``:
     590 The BSP ``LDFLAGS`` returned by ``pkgconfig``.
     591
     592``%{host_libs}``:
     593 The libraries needed to be linked to create an executable. If LibBSD is
     594 installed the library ``-lbsd`` is added. If the BSP has installed the RTEMS
     595 default configuration library (``-lrtemsdefaultconfig``) it is added to the
     596 list of libraries.
     597
     598``%{host_build_flags}``:
     599 This macro is defined in ``defaults.mc`` and is a series of shell commands
     600 that set up the environment to build an RTEMS package. If the host and the
     601 build triplets are the same it is a native build for your development host. If
     602 the host is not the build machine it is a cross-complitation build. For either
     603 case the following are defined.
     604
     605``%{_host_os}``:
     606 The host operating system extracted from the ``--host`` command line
     607 option. For example the operating sstem for the host of ``arm-rtems5`` is
     608 ``rtems5``.
     609
     610``%{_host_arch}``:
     611 The host architecture extracted from the ``--host`` command line option. For
     612 example the architecture for the host of ``arm-rtems5`` is ``arm``.
     613
     614``%{_host_cpu}``:
     615 The host cpu extracted from the ``--host`` command line option. For
     616 example the cpu for the host of ``arm-rtems5`` is ``arm``.
  • user/start/prefixes.rst

    r6185f6e rbb47f89  
    2121:file:`/usr/local` on FreeBSD and Linux.
    2222
    23 You have to select a prefix for your RTEMS tool suite installation.  The RTEMS
    24 tool suite consists of a cross tool chain (Binutils, GCC, GDB, Newlib, etc.)
    25 for your target architecture and :ref:`other tools <HostTools>` provided by the
    26 RTEMS Project.  You build and install the tool suite with the
    27 :ref:`RTEMS Source Builder (RSB) <RSB>`.  By default, the RSB will start the
    28 prefix path with a host operating system specific path plus :file:`rtems` plus
    29 the RTEMS version, e.g.  :file:`/opt/rtems/5` on Linux and
    30 :file:`/usr/local/rtems/5` on FreeBSD and macOS.
     23You have to select a prefix for your installation. You will build and install
     24the RTEMS tool suite, an RTEMS kernel for a BSP and you may build and install
     25third party libraries. You can build them all as a stack with a single prefix
     26or you can
     27
     28The RTEMS tool suite consists of a cross tool chain (Binutils, GCC, GDB,
     29Newlib, etc.)  for your target architecture and :ref:`other tools <HostTools>`
     30provided by the RTEMS Project. The RTEMS
     31
     32
     33You build and install the tool suite with the :ref:`RTEMS Source Builder (RSB)
     34<RSB>`.  By default, the RSB will start the prefix path with a host operating
     35system specific path plus :file:`rtems` plus the RTEMS version, e.g.
     36:file:`/opt/rtems/5` on Linux and :file:`/usr/local/rtems/5` on FreeBSD and
     37macOS.
    3138
    3239It is strongly recommended to run the RSB as a *normal user* and not with
Note: See TracChangeset for help on using the changeset viewer.