-
Notifications
You must be signed in to change notification settings - Fork 1
/
README
199 lines (117 loc) · 6.02 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
Simple-Linux
------------
Simple-linux is a set of scripts for simply and quickly building a runnable
embedded linux system. It is targeted at generating the simplest possible
system that can be run on various architecture and machine QEMU emulations.
Initially is support for generating a non-MMU based ColdFire/M5208EVB
linux image. It runs in QEMU or can be run on real hardware. Next was
added support for building ELF based m68knommu systems, then support for
building an ARM nommu system as well. The latest addition is for building
a minimal RISC-V based system. More will follow over time.
This is designed to be as absolutely simple and minimal as possible.
Only the first stage gcc is built (that is all we really need) and
only the busybox package to provide a very basic user space. There are
many fully fledged build systems out there, but these scripts are designed
to be the absolute simplest possible build. The idea is that it shows
the core requirements (or from scratch if you like) procedure in building
a running system. QEMU provides the perfect means to try out the build.
The build starts by building binutils and a first pass minimal gcc,
then builds uClibc (or musl as appropriate), busybox and finally a kernel.
All source packages will be downloaded if not already present locally.
The resulting kernel can be run using QEMU.
M68K nommu
----------
The traditional m68knommu build uses flat format executables. So the
simplest and most strait forward build uses that. Once you have installed
the simple-linux files locally, run the build script:
./build-m68knommu-linux-uclibc-flt.sh
and then run the resulting system:
qemu-system-m68k -nographic -machine mcf5208evb -kernel linux-6.11/vmlinux
There is also now an experimental build using ELF format executables.
You can try that out with:
./build-m68knommu-linux-uclibc-elf.sh
It can be run with same QEMU command line as above.
ARM
---
QEMU has a nice ARM/versatile board emulation that is ideal for testing
simple ARM systems.
./build-arm-linux-musl-elf.sh
and then run the resulting system:
qemu-system-arm -M versatilepb -nographic -kernel linux-6.11/arch/arm/boot/zImage -dtb linux-6.11/arch/arm/boot/dts/arm/versatile-pb.dtb
There is also a uclibc based ARM build:
./build-arm-linux-uclibc-elf.sh
Run with the same qemu command line above.
ARM nommu
---------
QEMU has a nice ARM/versatile board emulation that is ideal for testing
no-mmu ARM systems. The catch is that the kernel support for versatile
running with no MMU has been broken for a few years now. It is easy to
fix up with a patch, and that is included here. For a simple flat format
build:
./build-armnommu-linux-uclibc-flt.sh
and then run the resulting system:
qemu-system-arm -M versatilepb -nographic -kernel linux-6.11/arch/arm/boot/zImage -dtb linux-6.11/arch/arm/boot/dts/arm/versatile-pb.dtb
There is also now an experimental build using ELF format executables.
You can try that out with:
./build-armnommu-linux-uclibc-elf.sh
It can be run with same QEMU command line as above.
There is also a system build using ELF-FDPIC format binaries. The running
system is essentially indistinguishable from any other nommu ARM system,
as you would expect. Run with QEMU command line as above.
If you want an ARM Cortex-M based system then you can do that too.
Build a Cortex-3 based MPS2-AN385 system and run that in qemu with:
./build-cortexm-linux-uclibc-flt.sh
qemu-system-arm -M mps2-an385 -cpu cortex-m3 -nographic -kernel bootwrapper/linux.axf
RISC-V
------
QEMU has a nice generic RISC-V based system emulation that is ideal for
testing RISC-V based Linux systems. This build uses the musl C-library
instead of uClibc, but is otherwise similar to the other simple Linux
builds. Build with:
./build-riscv-linux-musl-elf.sh
and then run the resulting system:
qemu-system-riscv64 -nographic -machine virt -bios opensbi/build/platform/generic/firmware/fw_jump.elf -kernel linux-6.11/arch/riscv/boot/Image
Or alternatively you can do a build using uClibc instead of musl with:
./build-riscv-linux-uclibc-elf.sh
Run with the same QEMU command line as above.
RISC-V nommu
------------
The first nommu support for RISC-V used the traditional flat format binaries.
Run the build script for this with:
./build-riscvnommu-linux-uclibc-flt.sh
Run the resulting system:
qemu-system-riscv64 -cpu rv64,mmu=false -nographic -machine virt -bios linux-6.11/arch/riscv/boot/Image
There is now also an experimental RISC-V nommu build that supports ELF format
binaries. Note this is not ELF-FDPIC, but rather PIE style ELF binaries -
but it does use the linux kernels ELF-FDPIC program loader.
To build that:
./build-riscvnommu-linux-uclibc-elf.sh
and then run the resulting system as above for flat format binaries.
RISC-V 32-BIT
-------------
QEMU can also emulate 32-bit RISC-V processors. Run the build script for
taht with:
./build-riscv32-linux-musl-elf.sh
And run the resulting system with:
qemu-system-riscv32 -nographic -machine virt -bios opensbi/build/platform/generic/firmware/fw_jump.elf -kernel linux-6.11/arch/riscv/boot/Image
XTENSA nommu
------------
The first nommu support for XTENSA used the traditional flat format binaries.
Run the build script for this with:
./build-xtensanommu-linux-uclibc-flt.sh
Run the resulting system:
qemu-system-xtensa -M lx60 -cpu dc233c -nographic -kernel linux-6.11/arch/xtensa/boot/Image.elf
There is now also an experimental XTENSA nommu build that supports ELF format
binaries. Note this is not ELF-FDPIC, but rather PIE style ELF binaries -
but it does use the linux kernels ELF-FDPIC program loader.
To build that:
./build-xtensanommu-linux-uclibc-elf.sh
and then run the resulting system as above for flat format binaries.
ALPHA
-----
It is simple to create an ALPHA architecture build target that runs under
qemu. This is useful for testing the kernel and uClibc on alpha. To build
that:
./build-alpha-linux-uclibc-elf.sh
Run the resulting system:
qemu-system-alpha -kernel linux-6.11/vmlinux