Differences between revisions 22 and 53 (spanning 31 versions)
⇤ ← Revision 22 as of 2012-11-29 10:18:41 →
Size: 8574
Editor: ZaheerChothia
Comment: Incompatibility with gold linker
← Revision 53 as of 2016-12-22 21:49:03 → ⇥
Size: 4915
Editor: MoritzHoffmann
Comment: correct apt-get syntax
Deletions are marked like this. Additions are marked like this.
Line 5: Line 5:
To run Barrelfish on the Pandaboard, have a look at [[PandaBoard]].
Line 7: Line 9:
 * GCC 4.x
    4.4.5 and 4.5.2 are known to work. However, 4.4.5 throws compile warnings when building the current release as it does not support flags used by the Makefile, so 4.5.x is recommended.
 * GNU binutils 2.19 and 2.20 are known to work		  * GCC 5.4.0
 * GNU binutils 2.26.1 are known to work
Line 12: Line 13:
      Some versions of GHC are not supported. See [[#ghc|Section on GHC]] for more informations
 * Non-kvm QEMU. The kvm version causes runtime errors, see known issues.		       Some versions of GHC are not supported. See [[#ghc|Section on GHC]] for more information
Line 15: Line 15:
We are running nightly build tests on the latest Ubuntu LTS release (16.04.x) and are ensuring Barrelfish always builds using the Ubuntu versions of the above-mentioned tools. You can get a full build environment on Ubuntu by running the following command

{{{{
$ sudo apt-get install build-essential bison flex cmake qemu-system-x86 qemu-system-arm ghc libghc-src-exts-dev libghc-ghc-paths-dev libghc-parsec3-dev libghc-random-dev libghc-ghc-mtl-dev libghc-src-exts-dev libghc-async-dev gcc-arm-linux-gnueabi g++-arm-linux-gnueabi libgmp3-dev cabal-install curl freebsd-glue libelf-freebsd-dev libusb-1.0-0-dev qemu-utils gcc-aarch64-linux-gnu g++-aarch64-linux-gnu
$ cabal install bytestring-trie
}}}}

Note: Sometimes cabal fails because its repository, [[hackage.haskell.org]], is down. In this case a mirror can be used, for example as documented in [[https://www.fpcomplete.com/blog/2015/03/hackage-mirror]].
Line 19: Line 27:
hg clone http://hg.barrelfish.org
}}}}
or, if you are using an HTTP proxy:
{{{{
hg --config http_proxy.host=ipOfYourProxyServer:portOfYourProxyServer --config http_proxy.user=user --config http_proxy.passwd=password clone http://hg.barrelfish.org		 git clone git://git.barrelfish.org/git/barrelfish
Line 30: Line 34:
cd hg.barrelfish.org cd barrelfish
Line 38: Line 42:
We use [[http://barrelfish.org/TN-003-Hake.pdf|hake]] to build barrelfish.  We use [[http://barrelfish.org/TN-003-Hake.pdf|hake]] to build barrelfish.
Line 40: Line 44:
    * You need ghc. See the [[http://hg.barrelfish.org/file/tip/README|README]] file for a list of supported versions. In case your version of GHC is not supported: read section [[#ghcInstall|GHC Installation]]
    * Packages
      * libghc6-ghc-paths-dev
      * libghc6-parsec2-dev
    * You may also need to install the libgmp3-dev package		     * You need ghc. See the [[http://git.barrelfish.org/?p=barrelfish;a=blob;f=README|README]]. Please, read section [[#ghcVers|GHC Versions]] for more details.
    * Packages (already installed if you've followed the steps in the requirement section)
      * libghc-ghc-paths-dev
      * libghc-parsec3-dev
      * libghc-ghc-mtl-dev
      * libghc-src-exts-dev
      * libghc-async-dev
      * libghc-src-exts-dev
      * libghc-random-dev
      * freebsd-glue
      * libelf-freebsd-dev
      * and via Cabal: bytestring-trie
Line 46: Line 57:
==== GHC Installation ====
<<Anchor(ghcInstall)>>		 ==== GHC Versions ====
<<Anchor(ghcVers)>>
7.10.3 is the version we use internally (read: the version Ubuntu 16.04 LTS ships). Note that Haskell/GHC tends to be not very backwards compatible even for different minor versions. Therefore, it is strongly recommended to use the version that Ubuntu LTS is currently shipping.
Line 49: Line 61:
As described in the [[http://hg.barrelfish.org/file/tip/README|README]] file, some GHC versions have a bug and therefore cause problems building Barrelfish.
This section describes how to get version GHC 6.10.4 from the haskell website. You should skip this section if you already have a supported version of GHC.

On Ubuntu 11.10 (64 Bit) you might have to install `libgmp3c2` in order to configure and make install the downloaded ghc.

Ubuntu Lucid for example is shipped with version 6.12.1 of GHC. We are going to install an older version of the compiler, GHC 6.10.4, which is known to work.

 1. Fetch binary archive from [[http://www.haskell.org/ghc/download_ghc_6_10_4.html|haskell.org]] and set it up
 1. Install "cabal-install" (e.g. apt-get). As "normal" user (not root), execute:
  a. cabal update
  a. cabal install ghc-paths

Now, GHC 6.10.4 is the default version for the current user. Therefore, there is nothing more to do.
Line 69: Line 68:
or, if you wish to build the 32-bit version:
{{{{
../hake/hake.sh -s .. -a x86_32
}}}}
Line 75: Line 71:
../hake/hake.sh -s .. -a arm ../hake/hake.sh -s .. -a armv7
Line 77: Line 73:
or or (experimental)
Line 79: Line 75:
../hake/hake.sh -s .. -a arm11mp ../hake/hake.sh -s .. -a armv8
Line 81: Line 77:
or
To see what make targets are available for building Barrelfish run
Line 83: Line 80:
../hake/hake.sh -s .. -a arm_gem5 make help-platforms
Line 85: Line 82:

To see what make targets are available for running Barrelfish run
{{{{
make help-boot
}}}}
Line 88: Line 91:
../hake/Main.hs:369:25:
    Not in scope: data constructor `Opt_DeriveDataTypeable'		 stack overflow: use +RTS -K<size> to increase it
Line 91: Line 93:
Apply the following patch to hake/Main.hs: [[https://lists.inf.ethz.ch/pipermail/barrelfish-users/attachments/20110519/833cc2f8/attachment.obj|Main.hs.patch]] Try to avoid having the build directory in the source tree
Line 95: Line 97:
Now we can build Barrelfish: Now we can build Barrelfish. The following target builds the basic binaries for X86.
Line 97: Line 99:
make make X86_64_Basic
Line 102: Line 104:
make -j 5 make -j 5 X86_64_Basic
Line 107: Line 109:
make sim make qemu_x86_64
Line 109: Line 111:
To allocate more cores to QEMU, instead of the default 2, you can edit the symbolic_targets.mk file in the build directory. Do this by editing the QEMU_CMD line for the architecture you've chosen for Barrelfish.
To change options for QEMU, such as allocating more cores, you might want to execute the '''tools/qemu_wrapper.sh''' directly.
The following commands allocates 4 cores.
{{{{
../tools/qemu-wrapper.sh --menu ./platforms/x86/menu.lst.x86_64 --arch x86_64 --smp 4
}}}}
Line 113: Line 122:
=== QEMU-kvm ===
If you get the following error when booting Barrelfish:
{{{{
ERROR: pci.0 in AcpiOsInstallInterruptHandler() ../usr/pci/acpica_osglue.c:831
ERROR: failed to route interrupt
Failure: ( pci) Unknown global system interrupt number [PCI_ERR_UNKNOWN_GSI]
Assertion failed on core 0 in pci: r == 0, function init_acpi, file ../usr/pci/acpi.c, line 725.
Aborted
}}}}
This is most likely due to Barrelfish being run inside QEMU-kvm.
To fix this you can add '-no-kvm' to the QEMU_CMD in build/symbolic_targets.mk
Alternatively, if you have an intel CPU, you can issue the following command as root: 'rmmod kvm_intel kvm'

=== GHC 6.12.1/GHC 6.12.2 ===
There is a bug in some versions of GHC 6.12.2 on ubuntu and GHC 6.12.1 which causes the Barrelfish build to fail.
If you see errors like the following:
{{{{
../tools/fof/IL/FoF/Compile.lhs:71:18:
    Can't find interface-file declaration for variable freshVar
      Probable cause: bug in .hi-boot file, or inconsistent .hi file
      Use -ddump-if-trace to get an idea of which file caused the error
    In the expression: freshVar binding
    In the definition of `loc': loc = freshVar binding
    In the definition of `getFreshVar':
        getFreshVar binding
                      = (loc, binding1)
                      where
                          loc = freshVar binding
                          binding1 = binding {freshVar = loc + 1}
 
../tools/fof/IL/FoF/Compile.lhs:72:23:
    Can't find interface-file declaration for variable freshVar
      Probable cause: bug in .hi-boot file, or inconsistent .hi file
      Use -ddump-if-trace to get an idea of which file caused the error
    In the expression: binding {freshVar = loc + 1}
    In the definition of `binding1':
        binding1 = binding {freshVar = loc + 1}
    In the definition of `getFreshVar':
        getFreshVar binding
                      = (loc, binding1)
                      where
                          loc = freshVar binding
                          binding1 = binding {freshVar = loc + 1}
 
../tools/fof/IL/FoF/Compile.lhs:92:6:
    Can't find interface-file declaration for variable freshVar
      Probable cause: bug in .hi-boot file, or inconsistent .hi file
      Use -ddump-if-trace to get an idea of which file caused the error
    In the expression:
        stableBinding
          {freshVar = freshVar upBinding, defStructs = defStructs upBinding,
           defUnions = defUnions upBinding, defEnums = defEnums upBinding}
    In the definition of `passFreshVar':
        passFreshVar upBinding stableBinding
                       = stableBinding
                           {freshVar = freshVar upBinding, defStructs = defStructs upBinding,
                            defUnions = defUnions upBinding, defEnums = defEnums upBinding}
}}}}
See [[#ghcInstall|this section]] on how to fix this.

=== GCC 4.6.x ===
Compilation will fail due to new warnings which have been introduced in GCC 4.6.x, these warnings can be suppressed with two flags:
{{{{
-Wno-unused-but-set-variable -Wno-format
}}}}
These must be added to the build rules file for the architecture you are building for. These are all contained in hake/. For example, for the x86_64 target, the file is X86_64.hs. The variables which must have the flags added to them are '''ourCommonFlags''' and '''kernelCFlags'''. After modifying the file, just run make and the necessary files will be recompiled and the makefile will be regenerated and compilation will resume.

'''Note:''' these flags cannot simply be added to ArchDefaults.hs as the kernel flags are specified individually for each architecture. However, this may be simpler if you are compiling Barrelfish for multiple architectures.
Line 183: Line 123:
GNU binutils includes an ELF linker named "''gold''" which is faster than the default BFD linker for large C++ applications. When linking Barrelfish's CPU driver you may see the following error: GNU binutils includes an ELF linker named "''gold''" which is faster than the default BFD linker for large C++ applications. However, when linking Barrelfish's CPU driver you may see the following error:

The goal of this article is to guide you through compiling and running Barrelfish inside QEMU, and to write and run programs on Barrelfish itself. The instructions below assume you are using a recent version of Ubuntu.

To run Barrelfish on the Pandaboard, have a look at PandaBoard.

Requirements

Barrelfish requires the following tools to compile correctly:

  • GCC 5.4.0
  • GNU binutils 2.26.1 are known to work
  • GNU make
  • GHC and some additional libraries

    • Some versions of GHC are not supported. See Section on GHC for more information

We are running nightly build tests on the latest Ubuntu LTS release (16.04.x) and are ensuring Barrelfish always builds using the Ubuntu versions of the above-mentioned tools. You can get a full build environment on Ubuntu by running the following command 

$ sudo apt-get install build-essential bison flex cmake qemu-system-x86 qemu-system-arm ghc libghc-src-exts-dev libghc-ghc-paths-dev libghc-parsec3-dev libghc-random-dev libghc-ghc-mtl-dev libghc-src-exts-dev libghc-async-dev gcc-arm-linux-gnueabi g++-arm-linux-gnueabi libgmp3-dev cabal-install curl freebsd-glue libelf-freebsd-dev libusb-1.0-0-dev qemu-utils gcc-aarch64-linux-gnu g++-aarch64-linux-gnu
$ cabal install bytestring-trie

Note: Sometimes cabal fails because its repository, hackage.haskell.org, is down. In this case a mirror can be used, for example as documented in https://www.fpcomplete.com/blog/2015/03/hackage-mirror.

Getting Barrelfish

First we need to get the latest version of Barrelfish from the mercurial repository. Use the following command: 

git clone git://git.barrelfish.org/git/barrelfish

Configuring

Once you have cloned the repository, cd into it, create a build directory, and enter it: 

cd barrelfish
mkdir build
cd build

Prepare for build: The hake build system

We use hake to build barrelfish.

  • You need ghc. See the README. Please, read section GHC Versions for more details.

  • Packages (already installed if you've followed the steps in the requirement section)
    • libghc-ghc-paths-dev
    • libghc-parsec3-dev
    • libghc-ghc-mtl-dev
    • libghc-src-exts-dev
    • libghc-async-dev
    • libghc-src-exts-dev
    • libghc-random-dev
    • freebsd-glue
    • libelf-freebsd-dev
    • and via Cabal: bytestring-trie

GHC Versions

7.10.3 is the version we use internally (read: the version Ubuntu 16.04 LTS ships). Note that Haskell/GHC tends to be not very backwards compatible even for different minor versions. Therefore, it is strongly recommended to use the version that Ubuntu LTS is currently shipping.

Build barrelfish

Then create the required makefile: 

../hake/hake.sh -s .. -a x86_64

Valid arm targets are: 

../hake/hake.sh -s .. -a armv7

or (experimental) 

../hake/hake.sh -s .. -a armv8

To see what make targets are available for building Barrelfish run 

make help-platforms

To see what make targets are available for running Barrelfish run 

make help-boot

Note: If you get the following error: 

stack overflow: use +RTS -K<size> to increase it

Try to avoid having the build directory in the source tree

Compiling

Now we can build Barrelfish. The following target builds the basic binaries for X86. 

make X86_64_Basic

To speed things up you can specify a number of jobs. This should ideally be slightly more than the number of cores, so on a 4-core machine you could use: 

make -j 5 X86_64_Basic

Once that has completed, you can issue the following command to run Barrelfish on QEMU: 

make qemu_x86_64

To change options for QEMU, such as allocating more cores, you might want to execute the tools/qemu_wrapper.sh directly. The following commands allocates 4 cores. 

../tools/qemu-wrapper.sh --menu ./platforms/x86/menu.lst.x86_64 --arch x86_64  --smp 4

Known Issues

Gold linker

GNU binutils includes an ELF linker named "gold" which is faster than the default BFD linker for large C++ applications. However, when linking Barrelfish's CPU driver you may see the following error: 

/usr/bin/ld: fatal error: -pie and -static are incompatible
collect2: error: ld returned 1 exit status
make: *** [x86_64/sbin/cpu] Error 1

To fix this issue uninstall the binutils-gold package. For further details on why this occurs see this discussion.

BarrelfishWiki: Getting_Started (last edited 2016-12-22 21:49:03 by MoritzHoffmann)