<h1>OpenWrt Buildroot</h1>
</div>
- <p>Usage and documentation by Felix Fietkau, based on uClibc Buildroot
+ <p>Usage and documentation by Felix Fietkau and Waldemar Brodkorb, based on uClibc Buildroot
documentation by Thomas Petazzoni. Contributions from Karsten Kruse,
Ned Ludd, Martin Herren.</p>
<code>gcc</code>, <code>binutils</code>, uClibc and all the tools by hand.
Of course, doing so is possible. But dealing with all configure options,
with all problems of every <code>gcc</code> or <code>binutils</code>
- version it very time-consuming and uninteresting. OpenWrt Buildroot automates this
+ version is very time-consuming and uninteresting. OpenWrt Buildroot automates this
process through the use of Makefiles, and has a collection of patches for
each <code>gcc</code> and <code>binutils</code> version to make them work
- on the MIPS architecture of most Broadcom based Wireless Routers.</p>
+ on the MIPS architecture of most Wireless Routers.</p>
<h2><a name="download" id="download"></a>Obtaining OpenWrt Buildroot</h2>
- <p>OpenWrt Buildroot is currently available as experimental snapshots</p>
-
- <p>The latest snapshot is always available at <a
- href="http://openwrt.org/downloads/experimental/">http://openwrt.org/downloads/experimental/</a>,
+ <p>OpenWrt Buildroot is available via CVS - Concurrent Version System.
+ For any kind of development you should get the latest version from cvs via:</p>
+<pre>
+ $ cvs -d:pserver:anonymous@openwrt.org:/openwrt co openwrt
+</pre>
<h2><a name="using" id="using"></a>Using OpenWrt Buildroot</h2>
<li>squashfs</li>
</ul>
<p><code>jffs2</code> contains a writable root filesystem, which will expand to
- the size of your flash image. Note that you if you use the generic firmware
- Image, you need to pick the right image for your Flash size, because of different
+ the size of your flash image. Note: if you use the generic firmware image, you
+ need to pick the right image for your flash size, because of different
eraseblock sizes.</p>
<p><code>squashfs</code> contains a read-only root filesystem using a modified
configuration, and the latter is used if you have selected
locale support.</li>
- <li>Run the compilation again</li>
+ <li>Run the compilation again.</li>
</ol>
<li><b>target</b> (in the <code>target</code> directory) contains the
Makefiles and associated files for software related to the generation of
- the target root filesystem image. Four types of filesystems are supported
+ the target root filesystem image and the linux kernel for the different
+ system on a chip boards, used in the Wireless Routers.
+ Two types of filesystems are supported
: jffs2 and squashfs.
</ul>
- <p>Each directory contains at least 3 files :</p>
+ <p>Each directory contains at least 2 files :</p>
<ul>
<li><code>Makefile</code> is the Makefile that downloads, configures,
is your architecture). This is where the cross compilation toolchain will
be compiled.</li>
- <li>Setup the staging directory (<code>build_ARCH/staging_dir/</code> by
+ <li>Setup the staging directory (<code>staging_dir_ARCH/</code> by
default). This is where the cross-compilation toolchain will be
installed. If you want to use the same cross-compilation toolchain for
other purposes, such as compiling third-party applications, you can add
- <code>build_ARCH/staging_dir/bin</code> to your PATH, and then use
+ <code>staging_dir_ARCH/bin</code> to your PATH, and then use
<code>arch-linux-gcc</code> to compile your application. In order to
setup this staging directory, it first removes it, and then it creates
various subdirectories and symlinks inside it.</li>
<li>Create the target directory (<code>build_ARCH/root/</code> by
default) and the target filesystem skeleton. This directory will contain
- the final root filesystem. To setup it up, it first deletes it, then it
+ the final root filesystem. To set it up, it first deletes it, then it
copies the skeleton available in <code>target/default/target_skeleton</code>
and then removes useless <code>CVS/</code> directories.</li>
use the toolchain that was generated by the Buildroot.</p>
<p>The toolchain generated by the Buildroot by default is located in
- <code>build_ARCH/staging_dir/</code>. The simplest way to use it
- is to add <code>build_ARCH/staging_dir/bin/</code> to your PATH
- environnement variable, and then to use
+ <code>staging_dir_ARCH</code>. The simplest way to use it
+ is to add <code>staging_dir_ARCH/bin/</code> to your PATH
+ environment variable, and then to use
<code>arch-linux-gcc</code>, <code>arch-linux-objdump</code>,
<code>arch-linux-ld</code>, etc.</p>
<p>For example, you may add the following to your
<code>.bashrc</code> (considering you're building for the MIPS
architecture and that Buildroot is located in
- <code>~/buildroot/</code>) :</p>
+ <code>~/openwrt/</code>) :</p>
<pre>
-export PATH=$PATH:~/buildroot/build_mips/bin/
+export PATH=$PATH:~/openwrt/staging_dir_mipsel/bin/
</pre>
<p>Then you can simply do :</p>
<pre>
-mips-linux-gcc -o foo foo.c
+mipsel-linux-uclibc-gcc -o foo foo.c
</pre>
<p><b>Important</b> : do not try to move the toolchain to an other
uClibc toolchain outside of buildroot</h2>
<p>By default, the cross-compilation toolchain is generated inside
- <code>build_ARCH/staging_dir/</code>. But sometimes, it may be useful to
+ <code>staging_dir_ARCH/</code>. But sometimes, it may be useful to
install it somewhere else, so that it can be used to compile other programs
- or by other users. Moving the <code>build_ARCH/staging_dir/</code>
+ or by other users. Moving the <code>staging_dir_ARCH/</code>
directory elsewhere is <b>not possible</b>, because they are some hardcoded
paths in the toolchain configuration.</p>
you can configure Buildroot to generate it elsewhere using the
option of the configuration tool : <code>Build options ->
Toolchain and header file location</code>, which defaults to
- <code>$(BUILD_DIR)/staging_dir/</code>.</p>
+ <code>staging_dir_ARCH/</code>.</p>
<h2><a name="downloaded_packages"
id="downloaded_packages"></a>Location of downloaded packages</h2>
downloaded by the <i>Makefiles</i> are all stored in the
<code>DL_DIR</code> which by default is the <code>dl</code>
directory. It's useful for example if you want to keep a complete
- version of Buildroot which is know to be working with the
+ version of Buildroot which is known to be working with the
associated tarballs. This will allow you to regenerate the
toolchain and the target filesystem with exactly the same
versions.</p>
<pre>
config BR2_PACKAGE_FOO
- tristate "foo"
- default n
+ tristate "foo - some nice tool"
+ default m if CONFIG_DEVEL
help
This is a comment that explains what foo is.
</pre>
+ <p>If you depend on other software or library inside the Buildroot, it
+ is important that you automatically select these packages in your
+ <code>Config.in</code>. Example if foo depends on bar library:
+ </p>
+<pre>
+config BR2_PACKAGE_FOO
+ tristate "foo - some nice tool"
+ default m if CONFIG_DEVEL
+ select BR2_PACKAGE_LIBBAR
+ help
+ This is a comment that explains what foo is.
+</pre>
+
<p>Of course, you can add other options to configure particular
things in your software.</p>
+ <h3><code>Config.in</code> in the package directory</h3>
+
+ <p>To add your package to the configuration tool, you need
+ to add the following line to <code>package/Config.in</code>,
+ please add it to a section, which fits the purpose of foo:
+
+<pre>
+comment "Networking"
+source "package/foo/Config.in"
+</pre>
+
<h3><code>Makefile</code> in the package directory</h3>
<p>To add your package to the build process, you need to edit
<p>As you can see, this short line simply adds the target
<code>foo</code> to the list of targets handled by OpenWrt Buildroot.</p>
-
- <p>In addition to the default dependencies, you make your package
- depend on another package (e.g. a library) by adding a line:
+ <p>In addition to the default dependencies, you make your package
+ depend on another package (e.g. a library) by adding a line:
<pre>
foo-compile: bar-compile
</pre>
- <h3>The <i>.control</i> file</h3>
+ <h3>The ipkg control file</h3>
<p>Additionally, you need to create a control file which contains
information about your package, readable by the <i>ipkg</i> package
- utility.</p>
+ utility. It should be created as file:
+ <code>package/foo/ipkg/foo.control</code></p>
<p>The file looks like this</p>
3 Section: net
4 Maintainer: Foo Software <foo@foosoftware.com>
5 Source: http://foosoftware.com
- 6 Description: Your Package Description
+ 6 Depends: libbar
+ 7 Description: Package Description
</pre>
<p>You can skip the usual <code>Version:</code> and <code>Architecture</code>
fields, as they will be generated by the <code>make-ipkg-dir.sh</code> script
- called from your Makefile</p>
+ called from your Makefile. The Depends field is important, so that ipkg will
+ automatically fetch all dependend software on your target system.</p>
<h3>The real <i>Makefile</i></h3>
afterwards.</p>
<pre>
- 1 #############################################################
- 2 # foo
- 3 #############################################################
- 4 PKG_NAME:=foo
- 5 PKG_VERSION:=1.0
- 6 PKG_RELEASE:=1
- 7 PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.gz
- 8 PKG_SITE:=http://www.foosoftware.org/downloads
- 9 PKG_DIR:=$(BUILD_DIR)/$(PKG_NAME)-$(PKG_VERSION)
- 10 PKG_IPK:=$(PACKAGE_DIR)/$(PKG_NAME)_$(PKG_VERSION)-$(PKG_RELEASE)_$(ARCH).ipk
- 11 PKG_IPK_DIR:=$(PKG_DIR)/ipkg
- 12
- 13 $(DL_DIR)/$(PKG_SOURCE):
- 14 $(WGET) -P $(DL_DIR) $(PKG_SITE)/$(PKG_SOURCE)
- 15
- 16 $(PKG_DIR)/.source: $(DL_DIR)/$(PKG_SOURCE)
- 17 zcat $(DL_DIR)/$(PKG_SOURCE) | tar -C $(BUILD_DIR) $(TAR_OPTIONS) -
- 18 touch $(PKG_DIR)/.source
- 19
- 20 $(PKG_DIR)/.configured: $(PKG_DIR)/.source
- 21 (cd $(PKG_DIR); \
- 22 $(TARGET_CONFIGURE_OPTS) \
- 23 CFLAGS="$(TARGET_CFLAGS)" \
- 24 ./configure \
- 25 --target=$(GNU_TARGET_NAME) \
- 26 --host=$(GNU_TARGET_NAME) \
- 27 --build=$(GNU_HOST_NAME) \
- 28 --prefix=/usr \
- 29 --sysconfdir=/etc \
- 30 );
- 31 touch $(PKG_DIR)/.configured;
- 32
- 33 $(PKG_DIR)/foo $(PKG_DIR)/.configured
- 34 $(MAKE) CC=$(TARGET_CC) -C $(PKG_DIR)
- 35
- 36 $(PKG_IPK): $(PKG_DIR)/$(PKG_BINARY)
- 37 $(SCRIPT_DIR)/make-ipkg-dir.sh $(PKG_IPK_DIR) $(PKG_NAME).control $(PKG_VERSION)-$(PKG_RELEASE) $(ARCH)
- 38 $(MAKE) prefix=$(PKG_IPK_DIR)/usr -C $(PKG_DIR) install
- 39 rm -Rf $(PKG_IPK_DIR)/usr/man
- 40 $(IPKG_BUILD) $(PKG_IPK_DIR) $(PACKAGE_DIR)
- 41
- 42 $(IPKG_STATE_DIR)/info/$(PKG_NAME).list: $(PKG_IPK)
- 43 $(IPKG) install $(PKG_IPK)
- 44
- 45 prepare: $(PKG_DIR)/.source
- 46 compile: $(PKG_IPK)
- 47 install: $(IPKG_STATE_DIR)/info/$(PKG_NAME).list
- 48 clean:
- 49 rm -rf $(PKG_DIR)
- 50 rm -f $(PKG_IPK)
+ 1 # $Id$
+ 2 include $(TOPDIR)/rules.mk
+ 3 PKG_NAME:=foo
+ 4 PKG_VERSION:=1.0
+ 5 PKG_RELEASE:=1
+ 6 PKG_MD5SUM:=4584f226523776a3cdd2fb6f8212ba8d
+ 8 PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.gz
+ 9 PKG_SOURCE_URL:=http://www.foosoftware.org/downloads
+ 10 PKG_DIR:=$(BUILD_DIR)/$(PKG_NAME)-$(PKG_VERSION)
+ 11 PKG_IPK:=$(PACKAGE_DIR)/$(PKG_NAME)_$(PKG_VERSION)-$(PKG_RELEASE)_$(ARCH).ipk
+ 12 PKG_IPK_DIR:=$(PKG_DIR)/ipkg
+ 13
+ 14 $(DL_DIR)/$(PKG_SOURCE):
+ 15 $(SCRIPT_DIR)/download.pl $(DL_DIR) $(PKG_SOURCE) $(PKG_MD5SUM) $(PKG_SOURCE_URL)
+ 16
+ 17 $(PKG_DIR)/.source: $(DL_DIR)/$(PKG_SOURCE)
+ 18 zcat $(DL_DIR)/$(PKG_SOURCE) | tar -C $(BUILD_DIR) $(TAR_OPTIONS) -
+ 19 touch $(PKG_DIR)/.source
+ 20
+ 21 $(PKG_DIR)/.configured: $(PKG_DIR)/.source
+ 22 (cd $(PKG_DIR); \
+ 23 $(TARGET_CONFIGURE_OPTS) \
+ 24 CFLAGS="$(TARGET_CFLAGS)" \
+ 25 ./configure \
+ 26 --target=$(GNU_TARGET_NAME) \
+ 27 --host=$(GNU_TARGET_NAME) \
+ 28 --build=$(GNU_HOST_NAME) \
+ 29 --prefix=/usr \
+ 30 --sysconfdir=/etc \
+ 31 );
+ 32 touch $(PKG_DIR)/.configured;
+ 33
+ 34 $(PKG_DIR)/$(PKG_NAME): $(PKG_DIR)/.configured
+ 35 $(MAKE) CC=$(TARGET_CC) -C $(PKG_DIR)
+ 36
+ 37 $(PKG_IPK): $(PKG_DIR)/$(PKG_NAME)
+ 38 $(SCRIPT_DIR)/make-ipkg-dir.sh $(PKG_IPK_DIR) $(PKG_NAME).control $(PKG_VERSION)-$(PKG_RELEASE) $(ARCH)
+ 39 $(MAKE) prefix=$(PKG_IPK_DIR)/usr -C $(PKG_DIR) install
+ 40 rm -Rf $(PKG_IPK_DIR)/usr/man
+ 41 $(IPKG_BUILD) $(PKG_IPK_DIR) $(PACKAGE_DIR)
+ 42
+ 43 $(IPKG_STATE_DIR)/info/$(PKG_NAME).list: $(PKG_IPK)
+ 44 $(IPKG) install $(PKG_IPK)
+ 45
+ 46 prepare: $(PKG_DIR)/.source
+ 47 compile: $(PKG_IPK)
+ 48 install: $(IPKG_STATE_DIR)/info/$(PKG_NAME).list
+ 49 clean:
+ 50 rm -rf $(PKG_DIR)
+ 51 rm -f $(PKG_IPK)
</pre>
<p>First of all, this <i>Makefile</i> example works for a single
the other <code>Makefile</code> files in the <code>package</code>
directory.</p>
- <p>At lines 4-11, a couple of useful variables are defined :</p>
+ <p>At lines 3-12, a couple of useful variables are defined :</p>
<ul>
<li><code>PKG_NAME</code> : The package name, e.g. <i>foo</i>.</li>
<li><code>PKG_RELEASE</code> : The release number that will be
appended to the version number of your <i>ipkg</i> package.
+ <li><code>PKG_MD5SUM</code> : The md5sum of the software archive.
+
<li><code>PKG_SOURCE</code> : The name of the tarball of
your package on the download website of FTP site. As you can see
<code>PKG_NAME</code> and <code>PKG_VERSION</code> are used.</li>
- <li><code>PKG_SITE</code> : The HTTP or FTP site from which
- the archive is downloaded. It must include the complete
+ <li><code>PKG_SOURCE_URL</code> : Space separated list of the HTTP
+ or FTP sites from which the archive is downloaded. It must include the complete
path to the directory where <code>FOO_SOURCE</code> can be
found.</li>
of <code>BUILD_DIR</code> which is created upon decompression of
the tarball.</li>
- <li><code>PKG_IPK</code> : The resulting <i>ipkg</i> pacakge
+ <li><code>PKG_IPK</code> : The resulting <i>ipkg</i> package
</ul>
- <p>Lines 13-14 defines a target that downloads the tarball from
+ <p>Lines 14-15 defines a target that downloads the tarball from
the remote site to the download directory
(<code>DL_DIR</code>).</p>
- <p>Lines 16-18 defines a target and associated rules that
+ <p>Lines 17-19 defines a target and associated rules that
uncompress the downloaded tarball. As you can see, this target
depends on the tarball file, so that the previous target (line
- 13-14) is called before executing the rules of the current
+ 14-15) is called before executing the rules of the current
target. Uncompressing is followed by <i>touching</i> a hidden file
to mark the software has having been uncompressed. This trick is
used everywhere in Buildroot <i>Makefile</i> to split steps
(download, uncompress, configure, compile, install) while still
having correct dependencies.</p>
- <p>Lines 20-31 defines a target and associated rules that
+ <p>Lines 21-32 defines a target and associated rules that
configures the software. It depends on the previous target (the
hidden <code>.source</code> file) so that we are sure the software has
been uncompressed. In order to configure it, it basically runs the
filesystem. Finally it creates a <code>.configured</code> file to
mark the software as configured.</p>
- <p>Lines 33-34 defines a target and a rule that compiles the
+ <p>Lines 34-35 defines a target and a rule that compiles the
software. This target will create the binary file in the
compilation directory, and depends on the software being already
configured (hence the reference to the <code>.configured</code>
file). It basically runs <code>make</code> inside the source
directory.</p>
- <p>Lines 36-40 defines a target and associated rules that create
+ <p>Lines 37-41 defines a target and associated rules that create
the <i>ipkg</i> package which can optionally be embedded into
the resulting firmware image. It depends on the binary file in
the source directory, to make sure the software has been compiled.
removed to save space.
Finally <code>IPKG_BUILD</code> is called to create the package.</p>
- <p>Line 42 and 43 define the installation target of your package,
+ <p>Line 43 and 44 define the installation target of your package,
which will embed the software into the target filesystem.</p>
- <p>Lines 45-50 define the main targets that the Makefile in the
+ <p>Lines 46-51 define the main targets that the Makefile in the
<code>package</code> dir calls.
<ul>
<li><code>prepare</code> : Download and unpack the source</li>
projects / openwrt.git / blobdiff