-
Notifications
You must be signed in to change notification settings - Fork 0
/
README
269 lines (204 loc) · 8.71 KB
/
README
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
This file shall briefly describe the ways how to handle the snapshot.
We would really like that you read all of the README before asking
questions, although this file might be longer than you (and we) want.
Thanks a lot in advance.
Host system requirements
========================
The host system must a be a x86 based system with a recent Linux
distribution installed and at least 2GB of free disk space.
All necessary tools required by the build are available from the provided
packages of the Linux distributions (except the cross compiler needed for
ARM compiles). You might want to run 'make check_build_tools' in the src/l4
directory to verify the common tools are installed.
You are free to use any Linux distribution you like, or even BSDs or any of
its derivatives. But then you should know the game. Especially tool
versions should be recent, as installed on the listed distributions below.
We are confident that the snapshot works on the following distributions:
- Debian 6.0 or later
- Ubuntu 11.10 or later
Cross compiling for ARM
=======================
For compiling software for the ARM target on an x86 host a cross compiler
is needed.
Mentor/Codesourcery provides the necessary cross-compiler for x86 hosts.
Install the 'GNU/Linux' version available at:
http://www.mentor.com/embedded-software/sourcery-tools/sourcery-codebench/editions/lite-edition/
'Sourcery G++ Lite 2011.03' is known to work.
Linaro provides cross-compilers:
https://launchpad.net/linaro-toolchain-binaries/+download
Alternatively:
You have your own gcc cross compiler with at least version 4.5 installed
that is known to be working.
Before compiling, make sure the compiler and its tools are available in
your PATH with the prefix arm-linux-, .e.g. arm-linux-gcc.
To ease this the bin directory in the snapshot contains a small script that
will call the compiler tools appropriately. Either put the bin directory
in your PATH environment variable or make this script available in your
local bin directory (an example is displayed after 'make setup').
The script will use the environment variable GCC_PATH_PREFIX to find the
compiler you installed. An example could be:
export GCC_PATH_PREFIX=/opt/arm-2011.03/bin/arm-none-linux-gnueabi-
The build script will take care of using the bin directory of the
snapshot but for convenient usage during development it is advised to have
the tool generally available.
Building
========
In the upper most directory of the archive (the same directory where this
README is located) contains a Makefile. To setup the snapshot issue
make setup
and to build it issue
make
in the snapshot directory. Add -j X as wanted.
Directory layout
================
- bin
arm-linux-*: Some scripts, one for calling compiler tools
appropriately.
- doc
source
Contains documentation automatically generated from the documented
source code. Overview documentation is also included there.
l4re-source.pdf: PDF file of the generated code
html: HTML version of the documentation. Can be viewed in any recent
web browser.
- obj
Generated object code will be placed under the obj directory.
fiasco
Fiasco build directories, e.g.:
arm-mpcore: configuration built for the ARM11MPCore board
arm-up: configuration built for QEmu (realview, single core)
ia32: configuration for x86-32
ux: configuration for Fiasco-UX (x86-32 host)
l4
L4Re build drectories, e.g:
arm-rv-arm9: L4Re built for ARM Realview target (compiled for ARMv5)
arm-rv-ca:: L4Re built for ARM Versatile Express target (compiled for Cortex-A)
x86: L4Re built for x86
l4linux
L4Linux build directories, e.g.:
ux: L4Linux build without drivers
- src
Contains the source code:
kernel/fiasco: Fiasco source
l4: L4Re source
l4linux: L4Linux
tools: Tools needed for compilation
- files
Miscellaneous files.
ramdisk-x86.rd: Ramdisks for (L4)Linux.
ramdisk-arm.rd: Ramdisks for (L4)Linux.
All object directories are built by default.
Serial Console
==============
If you happen to use Windows as your workstation OS we recommend using
PuTTY (free, open source tool, ask your favorite search engine) as a
terminal emulator. Hyperterm is not recommended because it is basically
unable to display all the output properly.
On Linux hosts the situation is much more relaxed, minicom and PuTTY are
known to work, as probably any other solution.
QEMU
====
To run the built system under QEMU, go to an appropriate l4/
obj-directory of your choice, such as obj/l4/x86, and run:
make qemu
This will display a dialog menu to let you choose an entry to boot. For
example, choose 'hello' and you should see the system starting and finally
see "Hello World" scroll by periodically.
Configuring Images and Search Paths
===================================
The configuration file to configure the contents of images and generally
the entries to boot is
src/l4/conf/modules.list
containing entries sections with modules for each entries listed.
The search paths required to find the binaries and files are configured
through Makeconf.boot file(s). Locations in the the src-directory as well
as in the obj-directories are checked. The locations are
src/l4/conf/Makeconf.boot and obj-dir/conf/Makeconf.boot.
The paths can be configured globally or per make target. Please refer to
src/l4/conf/Makeconf.boot.example for usage examples.
Generating Images
=================
To generate an image, for example to load on a target system,
go the build directory and issue:
make elfimage E=hello
to build the standard hello target as an ELF image.
You may specify any other entry with E=xxx from the modules.list file, or
leave it out to get a dialog displayed for interactive selection.
Type 'make help' in the l4/ directory or the build directory to see all
possible targets.
Adding your own code
====================
Your own code should be placed outside the snapshot directory. This allows
that the snapshot can be replaced with a more recent version without
needing to take care about your own files and directories.
Software components are usually put into so-called packages, and each
package has a structure like this:
pkgname/
doc/ - Documentation for the package
include/ - Public headers for the package
lib/ - Library code
src/
server/ - Program code
src/
This is just a recommended structure, it is not required to be like that.
What is built in defined in the Makefiles in each directory.
A typical Makefile looks like this:
PKGDIR ?= .
L4DIR ?= path/to/your/l4dir
# Statements specific to the used role
include $(L4DIR)/mk/<role>.mk
Role might be:
- subdir: Descent to further subdirectories
- lib: Build a library
- prog: Build a program
- include: Process include files
The directory l4/mk/tmpl contains a template package directory layout
structure and shows how a package might look like. It also contains
examples on what to do in the Makefiles.
A very basic example might go like this:
$ mkdir /tmp/myfirstpkg
$ cd /tmp/myfirstpkg
$ editor Makefile
$ cat Makefile
PKGDIR ?= .
L4DIR ?= /path/to/snapshot/src/l4
TARGET = myfirstprogram
SRC_C = main.c
include $(L4DIR)/mk/prog.mk
$ editor main.c
$ cat main.c
#include <stdio.h>
int main(void)
{
printf("Hello!\n");
return 0;
}
$ make O=/path/to/snapshot/obj/l4/arm-rv-arm9
...
$ ls /path/to/snapshot/obj/l4/arm-rv-arm9/bin/arm_rv/l4f/myfirstprogram
/path/to/snapshot/obj/l4/arm-rv-arm9/bin/arm_rv/l4f/myfirstprogram
$
Tips and tricks
===============
If you're just building for one build directory you can do the
following to avoid the O=... argument on every make call.
Put O=/path/to/the/build-dir into L4DIR/Makeconf.local
Also, you can just issue 'make' in the build directories directly.
Setup for multiple packages
===========================
Create a directory structure like this:
dir/
dir/pkg1
dir/pkg2
dir/pkg3
Put this Makefile into dir/Makefile:
PKGDIR = .
L4DIR ?= /path/to/your/l4dir/l4
TARGET = $(wildcard [a-zA-Z]*)
include $(L4DIR)/mk/subdir.mk
This will build all sub packages from within this directory. Make sure
to define L4DIR properly in every Makefile in the packages (or
alternatively, include a file which defines it, but this file has to be
absolute as well).
In the package directories you can have the normal Makefiles as in
l4/pkg/pkgname.