This whole page is mostly obsolete. See the Development HomePage instead.

This whole page is mostly obsolete. See the Development HomePage instead.

Your next job is to download the OE-related openembedded/ directory. You get them from the BitKeeper repo. (no you don't. the project no longer uses bitkeeper.) The process for doing this is documented at http://openembedded.org/cgi-bin/moin.cgi/BitKeeper, but you must get them from the following nslu2-linux repository instead of the ones stated on that page:

After downloading BitBake you will need to install the BitBake software. To install, cd into the BitBake directory you just created and type ./setup.py install --prefix=/usr/local --install-data=/usr/local/share

(If you get an error: "./setup.py: No such file or directory", then you might have to install python and then use the command # python setup.py install --prefix=/usr/local --install-data=/usr/local/share) - willpost

Your next job is to download the OE-related openembedded/ directory. You get them from the BitKeeper repo. The process for doing this is documented at http://openembedded.org/cgi-bin/moin.cgi/BitKeeper, but you must get them from the following nslu2-linux repository instead of the ones stated on that page:

export BBPATH=${BUILDDIR}:${PKGDIR}

You now have the option of following the StepByStepSetup, which will tell you what to do, without explaining much of the reasoning, or you can continue with the following steps, which give extra information, but require you to fill in some blanks.

You will also need to set up the BBPATH variable. It needs to contain /path/to/build:/path/to/openembedded. (The path to your build directory should come first.) BBPATH and other necessary variables that were set by oe.env can now be set with the script bitbake/contrib/bbdev.sh.

Use the usual upgrade method to load the openslug-nslu2-timestamp.flashdisk.img file, see HowTo.InstallUnslungFirmware.

Important: once you have installed the bitbake software the installed version takes precedence over the version in the svn tree. If you subsequently follow the StepByStepSetup instructions these do not install the software, but python will find the old installed versions. Either reinstall or remove or rename the installed bb directory.

Under some circumstances changes in bitbake itself may result in the system not building after a pull. You will then have to update the bitbake source code from svn. One example of the effects of this is at the end of StepByStepSetup. In general this is worth double checking if the build starts giving mysterious python tracebacks after a pull.

The temp build directory for OpenSlug requires approximately 2GB (2005-01-25).

As of 2005-01-18 the /home/slung directory needs at least 3.3GB. The temp build directory "/home/slug/build/tmp" for "bitbake unslung-image" needs 2.5GB and can be changed by editing /home/slug/build/conf/local.conf and adding TMPDIR=/new/path/to/tmp/dir.

You should have at least 512MB RAM to complete this process with reasonable amount of swapping.

As of 2005-01-18 the /home/slung directory need at least 3.3GB. The temp build directory "/home/slug/build/tmp" for "bitbake unslung-image" needs 2.5GB and can be changed by editing /home/slug/build/conf/local.conf and adding TMPDIR=/new/path/to/tmp/dir. The tmp dir should not be a symlink as this will break autconf.

 $ (cd openembedded ; bk pull ; bk -r co -q)

Speeding up the bitbake

It's possible to restrict the bitbake of the OpenEmbedded packages to only Unslung and OpenSlug packages. This reduces the numeber of packages from 2000 to around 330.

The instructions are on the the following page:

http://www.nslu2-linux.org/wiki/OpenEmbedded/NSLU2PackageSymlinks

By using NSLU2PackageSymlinks a Duron 2GHz with 768MB did a bitbake unslung image in 75 minutes.

Problems & Solutions

2005-01-19: There might be a problem doing a "bitbake unslung-image" without the NSLU2PackageSymlinks. Please try using the instructions on http://www.nslu2-linux.org/wiki/OpenEmbedded/NSLU2PackageSymlinks.

You should have at least 512MB RAM to complete this process with reasonable amount of swapping. It is sufficient with 3GB free disk space after installation of the require software.

The required hardware

You should have at least 512MB RAM to complete this process with reasonable amount of swapping. It is sufficient with 1GB free disk space after installation of the require software.

 $ chmod u+w ${OEBUILD}/conf/local.conf

Grabbing a template for this file from your openembedded/ directory and make it writable:

 $ chmod o+w ${OEBUILD}/conf/local.conf

NOTE: Your host name must be fully qualified (host.domainname) for this process to complete.

You will also need to set up the BBPATH variable. It needs to contain /path/to/build:/path/to/openembedded. BBPATH and other necessary variables that were set by oe.env can now be set with the script bitbake/contrib/bbdev.sh.

@@export OEROOT=/home/slug\\

@@export PKGDIR=${OEROOT}/openembedded\\

@@export BUILDDIR=${OEROOT}/build\\

@@export PYTHONPATH=/usr/local/lib/python2.3/site-packages/:$PYTHONPATH\\

export BBPATH=${BUILDIR}:${PKGDIR}

cd ${BUILDDIR}

NOTE: If you are upgrading from a pre-bitbake situation. It is better to redo this step.

    cd ${OEROOT}    
    rm -rf packages/
    bk clone bk://nslu2-linux.bkbits.net/openembedded

@@PKGDIR=$(OEROOT)/openembedded\\

Simply copy and paste the sample commands below into a file called bb.env and then the command source bb.env will get you going. (Note that this file will need to be modified to match the paths on your system, the OEROOT is probably the only one that needs changed if you've put your workspace in a different place)

Set up a workspace

 mkdir /home/slug

 cd /home/slug

Grabbing a template for this file from your openembedded/ directory:

  OEROOT = /home/slug\\

@@OEROOT=/home/slug\\

If you want to redo a build, or the build failed and you made some fixes, all you need to do is remove the entire .../build/tmp/ directory, and rerun the oemake unslung-image command. Before you do that, however, if you want to keep up to date, you might want to make sure you have the latest versions of everything in your openembedded/ directory by running:

 $ (cd openembedded ; bk pull ; bk -r co -q)

Creating and running the bb.env environment script

The oe.env file can no longer be used to set up the environmental variables. a similar file can be created from the code below. Simply copy and paste it into a file called bb.env and then the command source bb.env will get you going. (Note that this file will need to be modified to match the paths on your system, the OEROOT is probably the only one that needs changed)

Once you do that, your working environment has been set up and you're in the build/ directory, ready to go.

Note that all subsequent =bitbake= commands have to be run from within the build/ directory.

Sample bb.env file:

OEROOT=/...whatever.../(the folder that contains the dir openembbeded)
#the directory into which you downloaded everything

PKGDIR=$(OEROOT)/openembedded/packages
#the directory that contains all of the packages

BUILDDIR=$(OEROOT)/build
#directory where all builds are done

PYTHONPATH=/usr/local/lib/python2.3/site-packages/:$PYTHONPATH
#Setup python to find the bb module

BBPATH=$(BUILDIR):$(PKGDIR)

cd $(BUILDDIR)

 $ bitbake -cfetch unslung-image

 $ bitbake unslung-image

 $ bitbake openslug-image

You will also need to set up the BBPATH variable. It needs to contain /path/to/build:/path/to/openembedded. BBPATH and other necessary variables that were set by oe.env can now be set with the script bitbake/contribe/bbdev.sh.

You will also need to set up the BBPATH variable. It needs to contain /path/to/build:/path/to/openembedded.

 bk://nslu2-linux.bkbits.net/openembedded

Installing BitBake Software

After downloading BitBake you will need to install the BitBake software. To install, cd into the BitBake directory you just created and type ./setup.py install --prefix=/usr/local --install-data=/usr/local/share.

Now type bitbake at the command line and see if there are any errors. If you get an error about not being able to load the bb module you need to modify your PYTHONPATH variable. To do this type export PYTHONPATH=/usr/local/lib/python2.3/site-packages/:$PYTHONPATH.

1. download BitBake from the BitBake SubVersion repository
2. download the openembedded/ source from the nslu2-linux repository

1. $ bitbake unslung-image, whose eventual output will be a flashable image for your device

There is already a wiki page that describes what (non-OE) software should already exist on your Linux system -- see our http://www.nslu2-linux.org/wiki/OpenEmbedded/RequiredSoftware Required Software page.

• There is apparently no way to avoid building the documentation packages so, yes, you do need the various DocBook? and SGML tools. This is an unfortunate situation that is out of our hands (talk to the BitBake maintainers if you feel strongly about it).

Getting the BitBake software

Your first job is to download the BitBake software. Install SubVersion, and then run:

 svn co svn://svn.berlios.de/bitbake/trunk/bitbake

This will create a bitbake/ directory in the current directory. Remain in this current directory (not the bitbake subdirectory) for the following steps (all the other directories go alongside the bitbake/ directory).

Getting the OE packages and metadata

Your next job is to download the OE-related openembedded/ directory. You get them from the BitKeeper repo. The process for doing this is documented at http://openembedded.org/oe_wiki/index.php/BitKeeper, but you must get them from the following nslu2-linux repository instead of the ones stated on that page:

 bk://nslu2-linux.bkbits.net/packages

All you're after is the downloading and creation of one sibling directory:

• openembedded/ (about 100M)

Once you've downloaded the bitbake/ and openembedded/ directories, you need to create a few more directories and files to complete the picture before you can start your build. Here's a fairly generic directory structure you can use for the build, along with some representative variable names that, in some cases, match their usage in some of the configuration files:

   /home/slug/                (OEROOT, wherever you downloaded the previous stuff)
          bitbake/            (OESYS)
          openembedded/       (PKGDIR)

  BBFILES = ${OEROOT}/openembedded/packages/*/*.bb\\

Note that all subsequent =bitbake= commands have to be run from within the build/ directory.

http://www-106.ibm.com/developerworks/linux/library/l-ccache.html?ca=dgr-lnxw09ccache this, but you don't really need to know how it works to take advantage of it.

 $ bk pull; bk -r co -q

There is already a wiki page that describes what (non-OE) software should already exist on your Linux system -- see OE's http://www.nslu2-linux.org/wiki/OpenEmbedded/RequiredSoftware Required Software page.

• A FC2? system has only version 2.5.4 of the patch utility, but this seems to be adequate. I don't know of any compelling reason to have to upgrade to version 2.5.9 as the http://www.nslu2-linux.org/wiki/OpenEmbedded/RequiredSoftware Required Software page suggests; if anyone knows, feel free to add it here, but version 2.5.4 appears to work just fine.

The phases of the build

The required software

Where to next?

You now have the otion of following the StepByStepSetup, which will tell you what to do, without explaining much of the reasoning, or you can continue with the following steps, which give extra information, but require you to fill in some blanks.

Getting the OE software

The directory structure

Setting up your build/conf/local.conf file

Creating and running the oe.env environment script

Pre-fetching the sources

Building the image(s) and getting the results

Redoing the build from scratch

This document represents a step-by-step description of how to build the Unslung or OpenSlug firmware using OE. Thanks to Kergoth for writing the first version of this page.

In the case you are targeting an OpenSlug build, alternatively set

  DISTRO = openslug

or

 $ oemake openslug-image

You can grab a sample environment script file from the http://openembedded.org/oe_wiki/index.php/GettingStartedEnvironmentScript GettingStartedEnvironmentScript page, and copy it to, say, ${OEROOT}/oe.env. Unless you're doing something unusual, the only change you'll have to make is to set the actual OEROOT variable to the appropriate value. (Any other changes you might have to make should be obvious.)

This document represents a step-by-step description of how to build the Unslung firmware using OE. Thanks to Kergoth for writing the first version of this page.

  OEROOT = (whatever)
  DL_DIR = ${OEROOT}/sources
  OEFILES = ${OEROOT}/packages/*/*.oe
  MACHINE = nslu2\\

1. download the oe/ and packages/ source from the nslu2-linux repository

1. $ oemake unslung-image, whose eventual output will be a flashable image for your device

• A FC2? system has only version 2.5.4 of the patch utility, but this seems to be adequate. I don't know of any compelling reason to have to upgrade to version 2.5.9 as the http://openembedded.org/oe_wiki/index.php/RequiredSoftware RequiredSoftware page suggests; if anyone knows, feel free to add it here, but version 2.5.4 appears to work just fine.

• There is apparently no way to avoid building the documentation packages so, yes, you do need the various DocBook? and SGML tools. This is an unfortunate situation that will eventually be rectified.

• The http://psyco.sf.net Psyco JIT Compiler may be optional, but it's *strongly* recommended -- it will speed things up noticeably.

• The http://ccache.samba.org/ ccache compiler cache program is also optional, but if you're going to use it, note that it will only speed things up after your first build. It won't make any difference when you're starting from scratch. And if you plan on using it, apparently, you have to use it right from the beginning -- adding it later will cause problems with libtool. Bottom line -- use it right from the start, or don't use it at all.

Your first job is to download the OE-related oe/ and packages/ directories into the directory of your choice. You get them from the BitKeeper repo. The process for doing this is documented at http://openembedded.org/oe_wiki/index.php/BitKeeper, but you must get them from the following nslu2-linux repositories instead of the ones stated on that page:

• oe/ (about 1 M)
• packages/ (about 95M)

Once you've downloaded the oe/ and packages/ directories, you need to create a few more directories and files to complete the picture before you can start your build. Here's a fairly generic directory structure you can use for the build, along with some representative variable names that, in some cases, match their usage in some of the configuration files:

Of the above, you only need to create the build/conf/local.conf file; the other two directories will be created automatically when you do a build so you can ignore them for the time being.

• NOTE* that you can create the tmp/ and sources/ directories elsewhere if you want, just by setting the appropriate variables in your configuration file, as explained in the next section.

Setting up your build/conf/local.conf file

Grabbing a template for this file from your packages/ directory:

Creating and running the oe.env environment script

Once the toolchain is installed, you can grab a sample environment script file from the http://openembedded.org/oe_wiki/index.php/GettingStartedEnvironmentScript GettingStartedEnvironmentScript page, and copy it to, say, ${OEROOT}/oe.env. Unless you're doing something unusual, the only change you'll have to make is to set the actual OEROOT variable to the appropriate value. (Any other changes you might have to make should be obvious.)

Once you do that, your working environment has been set up and you're in the build/ directory, ready to go.

Note that all subsequent =oemake= commands have to be run from within the build/ directory.

When you eventually start a build, part of the build process is to download a pile of sources, by default into the directory ${OEROOT}/sources. If you want to get that out of the way first, or if you want to pre-fetch those sources in preparation for disconnecting from the net and still being able to do a build later, you can run:

This will load up your sources/ directory without actually starting the build process. Of course, this step is entirely optional. (On my system, that directory consumes about 230M of space, so you definitely want to have a fast net connection.)

All of the build intermediate results are placed in the directory ${OEROOT}/build/tmp, so make sure you have sufficient room for this. To build a minimal flashable image, run:

If you want to redo a build, or the build failed and you made some fixes, all you need to do is remove the entire .../build/tmp/ directory, and rerun the oemake unslung-image command. Before you do that, however, if you want to keep up to date, you might want to make sure you have the latest versions of everything in your oe/ and packages/ directories by running:

Overview

This document represents a step-by-step description of how to build the Unslung firmware using OE.

The phases of the build

The entire build is done in several steps (all of which are explained in detail below):

1. download the oe/ and packages/ source from the nslu2-linux repository
2. edit one or more configuration files to reflect that you're building for an nslu2
3. $ oemake unslung-image, whose eventual output will be a flashable image for your device

The required software

There is already a wiki page that describes what (non-OE) software should already exist on your Linux system -- see OE's http://openembedded.org/oe_wiki/index.php/RequiredSoftware RequiredSoftware page.

First, regarding the actual _required_ software, a couple of observations:

• A FC2? system has only version 2.5.4 of the =patch= utility, but this seems to be adequate. I don't know of any compelling reason to have to upgrade to version 2.5.9 as the http://openembedded.org/oe_wiki/index.php/RequiredSoftware RequiredSoftware page suggests; if anyone knows, feel free to add it here, but version 2.5.4 appears to work just fine.

• There is apparently no way to avoid building the documentation packages so, yes, you do need the various ~DocBook? and ~SGML tools. This is an unfortunate situation that will eventually be rectified.

Regarding what are actually _optional_ packages:

• The [Psyco JIT Compiler|http://psyco.sf.net] may be optional, but it's *strongly* recommended -- it will speed things up noticeably.

• The [ccache|http://ccache.samba.org/] compiler cache program is also optional, but if you're going to use it, note that it will only speed things up after your first build. It won't make any difference when you're starting from scratch. And if you plan on using it, apparently, you have to use it right from the beginning -- adding it later will cause problems with =libtool=. Bottom line -- use it right from the start, or don't use it at all.

If you want a tutorial on ccache, I suggest http://www-106.ibm.com/developerworks/linux/library/l-ccache.html?ca=dgr-lnxw09ccache, but you don't really need to know how it works to take advantage of it.

Getting the OE software

Your first job is to download the OE-related =oe/= and =packages/= directories into the directory of your choice. You get them from the ~BitKeeper repo. The process for doing this is documented at [http://openembedded.org/oe_wiki/index.php/BitKeeper], but you must get them from the following nslu2-linux repositories instead of the ones stated on that page:

bk://nslu2-linux.bkbits.net/oe bk://nslu2-linux.bkbits.net/packages

All you're after is the downloading and creation of two sibling directories:

• =oe/= (about 1 M)
• =packages/= (about 95M)

The directory structure

Once you've downloaded the =oe/= and =packages/= directories, you need to create a few more directories and files to complete the picture before you can start your build. Here's a fairly generic directory structure you can use for the build, along with some representative variable names that, in some cases, match their usage in some of the configuration files: <pre>

   .../myoestuff/             (OEROOT, wherever you downloaded the previous stuff)
          oe/                 (OESYS)
          packages/           (PKGDIR)

</pre>

In addition to the above, you'll have to create (or they'll be created for you) the following, also directly under your OEROOT directory: <pre>

          build/              (OEBUILD)
             conf/
                local.conf
             tmp/             (TMPDIR)
          sources/

</pre>

Of the above, you only need to create the =build/conf/local.conf= file; the other two directories will be created automatically when you do a build so you can ignore them for the time being.

• NOTE* that you can create the =tmp/= and =sources/= directories elsewhere if you want, just by setting the appropriate variables in your configuration file, as explained in the next section.

Setting up your =build/conf/local.conf= file

Grabbing a template for this file from your =packages/= directory:

<pre>

 $ cp ${PKGDIR}/conf/local.conf.sample ${OEBUILD}/conf/local.conf

</pre>

customize your copy of that file to reflect your build environment and final image, something along the lines of:

<verbatim>

  OEROOT = (whatever)
  DL_DIR = ${OEROOT}/sources
  OEFILES = ${OEROOT}/packages/*/*.oe
  MACHINE = nslu2
  DISTRO = unslung

</verbatim>

Finally, remove or comment out the last line -- the one containing "=REMOVE_THIS_LINE=".

Creating and running the =oe.env= environment script

Once the toolchain is installed, you can grab a sample environment script file from the [http://openembedded.org/oe_wiki/index.php/GettingStartedEnvironmentScript] page, and copy it to, say, =${OEROOT}/oe.env=. Unless you're doing something unusual, the only change you'll have to make is to set the actual =OEROOT= variable to the appropriate value. (Any other changes you might have to make should be obvious.)

After you make that change (or those changes), you can set up your build environment by simply "sourcing" the script with:

<pre>

 $ . ./oe.env

</pre>

Once you do that, your working environment has been set up and you're in the =build/= directory, ready to go.

Note that all subsequent =oemake= commands have to be run from within the =build/= directory.

Pre-fetching the sources

When you eventually start a build, part of the build process is to download a pile of sources, by default into the directory =${OEROOT}/sources=. If you want to get that out of the way first, or if you want to pre-fetch those sources in preparation for disconnecting from the net and still being able to do a build later, you can run:

<pre>

 $ oemake -cfetch unslung-image

</pre>

This will load up your =sources/= directory without actually starting the build process. Of course, this step is entirely optional. (On my system, that directory consumes about 230M of space, so you definitely want to have a fast net connection.)

Building the image(s) and getting the results

All of the build intermediate results are placed in the directory =${OEROOT}/build/tmp=, so make sure you have sufficient room for this. To build a minimal flashable image, run:

<pre>

 $ oemake unslung-image

</pre>

The results will show up in .../build/tmp/deploy/images/.

Redoing the build from scratch

If you want to redo a build, or the build failed and you made some fixes, all you need to do is remove the entire =.../build/tmp/= directory, and rerun the =oemake bootstrap-image= command. Before you do that, however, if you want to keep up to date, you might want to make sure you have the latest versions of everything in your =oe/= and =packages/= directories by running:

<pre>

 $ bk pull; bk -r co -q

</pre>

 MACHINE = "nslu2"
 DISTRO = "unslung"

http://openembedded.org/oe_wiki/index.php/RequiredSoftware

5.) build

openembedded for the NSLU2

the next version of the MeshCube? distribution will be based on the openembedded build system. openembedded is a very flexible source based meta distribution for embedded systems and cross-compiling. see http://openembedded.org/oe_wiki/ for more info.

our distribution within openembedded is called nylon, our hardware is called mtx-1. both together will be the MeshCube?.

The following steps should get you started with openembedded for the NSLU2.

Check http://openembedded.org/oe_wiki/index.php/GettingStarted for more information and help.

0.) Install required software

Required:

• python
• ccache
• patch
• m4
• sed
• docbook
• bison
• make
• openjade

Optional:

• psyco
• bitkeeper (http://www.bitkeeper.com/Products.Downloads.html)

http://openembedded.org/oe_wiki/index.php/RequiredSoftware

1.) get the oe files and packages with bitkeeper or get snapshots from http://treke.net/oe/snapshots/

 bk clone bk://openembedded.bkbits.net/oe oe
 bk clone bk://openembedded.bkbits.net/packages packages

2.) create necessary files:

a. create a file `conf/local.conf` with (at least) the following contents

 DL_DIR = "/your/path/to/oe/sources"
 OEFILES := "/your/path/to/oe/packages/*/*.oe"
 MACHINE = "Xscale"
 TARGET_OS = "linux"
 DISTRO = "OpenSLUG?"
 CACHE=/var/tmp/oe-cache.${USER}

b. create a script `env.sh` like this

 BASE=/data/mtx/oe/oe.write
 OEROOT=${BASE}/oe
 PKGDIR=${BASE}/packages
 OEBUILD=${BASE}
 DL_DIR=/data/mtx/oe/sources

 export OEPATH=${OEBUILD}:${PKGDIR}:${OEROOT}
 export PATH=$OEROOT/bin:${PATH}
 export LD_LIBRARY_PATH=
 export LANG=C

 echo "Altered environment for OE Development"

4.) set up the environment

you'll have to do this every time before you use openembedded!!!

 . env.sh

5.) build ==

now you can start building inside openembedded, eg, build the basic nylon image:

 oemake nlsu-image-base

oemake resolves all dependencies of a package. when it run for the first time, it will compile some native tools used by openembedded, then it will compile the toolchain, all required libraries, all required packages and finally create a jffs2 image which can then be loaded to the cube (see InstallFilesystemImages?). this will take some time, especially the first time, when the toolchain has to be build.

You can use oemake it to build any package including it's dependencies:

 oemake PACKAGENAME

If you want to build a specific version of a package, without all it's dependencies you can use

 oebuild packages/PACKAGE/PACKAGE_VERSION.oe

There are some special directories in the package/ directory, which may be worth of mentioning here:

 because current version of oemake takes lots of memory during work so swapping can eat you.

This mostly affects the packaging of glibc. To overcome this issue somewhat, if you have less than 512MB of RAM,you
can use "oebuild" to build glibc instead of oemake (oemake itself uses a lot of memory, so this makes more
of your RAM available to oebuild). To invoke oebuild, you must specify the location of the package
file and not just the package name. Remember that "oebuild" *does not* trace dependencies so you have to take
care of it by yourself (best method is oemake glibc and break when it start glibc unpacking - oebuild clean & oebuild).

(*Always read oe/doc/* first as this page may easily become outdated!*)

To start using OE, first get the code from BitKeeper. You need both the repositories 'oe' and 'packages'.

 /stuff/oe/
 /stuff/packages/
 /stuff/build/
 /stuff/sources/

 cd /stuff/build/
 mkdir conf/
 cat /stuff/packages/conf/local.conf.sample > conf/local.conf
 vi conf/local.conf

  $ . /stuff/env-dev-arm-oe.source

 oemake opie-image

Note: at least on my system I needed to have =ccache= installed

all ends up in the tmp directory. Most interesting is probably the tmp/work/ directory. Just have a look around the DirectoryStructure?.

Hardware

Make sure that you have at least 512MB of RAM in machine used for builds. With less memory it will take eons
because current version of "oemake" takes lots of memory during work so swapping can eat you.

This mostly affects the packaging of glibc. To overcome this issue somewhat, if you have less than 512MB of RAM,

 you can use "oebuild" to build glibc instead of "oemake" ("oemake" itself uses a lot of memory, so this makes more
 of your RAM available to "oebuild"). To invoke "oebuild", you must specify the location of the package
 file and not just the package name. Remember that "oebuild" *does not* trace dependencies so you have to take
care of it by yourself (best method is "oemake glibc" and break when it start glibc unpacking - "oebuild clean" & "oebuild").

Doing a build

(*Always read "oe/doc/*" first as this page may easily become outdated!*)

NB Do not build OE as root, you don't need to and strange things can and will happen. If you need root access for something
to work on your machine, the build environment is set up wrong.

To start using OE, first get the code from BitKeeper. You need both the repositories 'oe' and 'packages'.

If you are unable or unwilling to use BitKeeper, there are snapshots at http://treke.net/oe/snapshots/ . There is also [Anonymous CVS] available.

Make sure you have all the RequiredSoftware installed.

Check out or unpack the sources into a location with no symlinks above it. Let's assume that root directory of your OpenEmbedded enviroment
will be in /stuff/. Recommended structure is:

/stuff/oe/ /stuff/packages/ /stuff/build/ /stuff/sources/

Note: if you are using [Anonymous CVS] then you will get "oe-packages" instead of "packages". Rename it or remember that your enviroment differ a bit from this example.

Create local configuration

<verbatim> cd /stuff/build/ mkdir conf/ cat /stuff/packages/conf/local.conf.sample > conf/local.conf vi conf/local.conf </verbatim>

You'll probably want to add some mirrors to the end of =local.conf= --- see UsingMirrors?

Setup the environment

Check out the GettingStartedEnvironmentScript sample and customize it to your OE installation.

Save it as /stuff/env-dev-arm-oe.source or similar Then source it: <verbatim>

 $ . /stuff/env-dev-arm-oe.source

</verbatim>

Note: Sourcing this file will put you in your configured build directory. ALL oemake commands should be issue from this directory.

Start building

oemake

The primary interface to the build system is the "oemake" command (see the [oemake] page). <code>oemake</code> will download and patch stuff from the network, so it helps if you are on a well connected machine.

Here are some example invocations:

Building a single package (e.g. nano): <verbatim>

 oemake nano

</verbatim>

Building package sets (e.g. task-bootstrap): <verbatim>

 oemake task-bootstrap

</verbatim>

Building a group of packages and deploying them into a rootfs image:

GPE: <verbatim>

 oemake gpe-image

</verbatim>

OPIE: <verbatim> oemake opie-image </verbatim>

Building every package in the repository (Attention! This will take a long time and needs approx. 5 GB disk space): <verbatim>

 oemake world

</verbatim>

<b>Note</b>: at least on my system I needed to have =ccache= installed for the build to (mostly) work. (See also the RequiredSoftware page.)

See [UsefulTargets?] for a description of some of the more useful meta-packages.

Output of the build process (temporary files, log files and the binaries) all ends up in the <tt>tmp</tt> directory. Most interesting is probably the <tt>tmp/work/</tt> directory. Just have a look around the DirectoryStructure?.

Once you have managed to build a package, try to [BuildIPKFiles?].

Flashing your PDA

• Sharp Zaurus SL-5500 and SL-5000d*:

  Once you have finished building an image (e.g. <tt>opie-image</tt>) look for the image file in <tt>deploy/images</tt> under your TMPDIR (on my system this is called <tt>opie-image-collie-20040721193112.rootfs.jffs2</tt>) and copy it to the root directory of a CF card with name <tt>initrd.bin</tt>.%
  Then look for the kernel image under <tt>staging/arm-linux/kernel</tt>, this should just be called <tt>zImage</tt>, copy this to your CF card with name <tt>zImage</tt>.%
  Then hard reset your PDA holding down C+D buttons with the CF card inserted, this will cause the mail and battery lights to illuminate. Once the procedure has finished the mail and batery lights should turn off, at this point hard reset your PDA again and you should be booting into the system you just built (be it opie, gpe, etc.).

<b>Sharp Zaurus C7x0 and SL-5600</b>

 - Get http://openzaurus.org/official/experimental/c700,c750,c760,c860/3.3.6-pre1/updater.sh
    NOTE:It doesn't worked for me (SL-5600). Instead try http://openzaurus.org/official/experimental/poodle/3.3.6-pre1/updater.sh AND rename zimage.bin to zImage (capital letter i).
 - Rename stuff/build/tmp/deploy/images/gpe-image*.rootfs.img (or opie-image*.rootfs.img) to initrd.bin
 - Rename zImage.-embedix to zimage.bin  (Note: mine was here: stuff/build/tmp/work/openzaurus-pxa-2.4.18-rmk7-pxa3-embedix-r6/image/boot/zImage-2.4.18-rmk7-pxa3-embedix)
 - Copy initrd.bin, zimage.bin and updater.sh to your
   FAT-formatted CF or SD
 - Attach Power Cable
 - Reboot while pressing and holding OK on your machine
 - Choose 4 (Update Kernel)
 - Choose CF or SD (USB not tested, no idea)
 - Choose HAI (YES) (Left)

<b>iPAQ</b> :

  The boot loader distributed with familiar should be able to load the image via serial port, using the traditional "load root" command. To install (or upgrade) the boot loader of the familiar project see: http://familiar.handhelds.org/familiar/releases/latest/install/bootldr.html

  Basically, you just have to follow the installation instructions for familiar substituting the root image file with the one generated by OE rather than the one you obtained from familiar. The other method for flashing an image (using a CF card) should work as well. See http://familiar.handhelds.org/familiar/releases/latest/install/ for more information on the two methods.

<b>SIMpad?</b> :

  There are currently two ways to install the generated linux image onto a simpad.

  The first one uses a download via rs232 as described  here: http://opensimpad.org/wiki/index.php/Docs/SerialInstall . This approach may take half an hour and more to install the image, but it doesn't require a complex setup on the desktop pc.

  The second approach described in http://opensimpad.org/wiki/index.php/Docs/NetworkInstall uses a more complex setup and installs the image via a ne2000 compatible network card. This setup is a little more complicated, but is way faster.

<b>MasterIA? PA-100</b> : ... add me ...

Problems

Try to solve problems first by checking that you have done everything right, that nothing has changed from this description and that you have the latest code (see BitKeeper description). Look also in the log file (referenced in any error message you will receive). If you still have problems, try checking [PossibleFailures?], and if problems persist, ask on [IRC].

Portability issues

Make sure to set TARGET_OS to linux in local.conf if your host isn't linux.

GNU extensions to tools are often required. Symlink GNU patch, make, and cp (from fileutils) into your OE development path.

FreeBSD? 4 users: Perl 5.0 is too old. A more recent perl must be available as /usr/bin/perl. Unfortunately just having more recent perl in the path isn't good enough. Some scripts are hard-coded for /usr/bin/perl

FreeBSD? users: Set BUILD_OS in local.conf to freebsdN where N is your major version number. At least the cross gcc wants this.

__Install ccache__ When you rm -rf packages/tmp for the 20th time while trying to get things to work you'll be glad you did.

What's next?

See [OzTODO3?.5.1]