-
Notifications
You must be signed in to change notification settings - Fork 250
/
platform.cc
293 lines (227 loc) · 8.27 KB
/
platform.cc
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
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
/*
* \brief Platform interface implementation
* \author Norman Feske
* \date 2009-10-02
*/
/*
* Copyright (C) 2009-2012 Genode Labs GmbH
*
* This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2.
*/
/* Genode includes */
#include <base/printf.h>
#include <base/sleep.h>
#include <base/thread.h>
/* core includes */
#include <core_parent.h>
#include <platform.h>
#include <map_local.h>
/* Codezero includes */
#include <codezero/syscalls.h>
using namespace Genode;
enum { verbose_boot_info = true };
/*
* Memory-layout information provided by the linker script
*/
/* virtual address range consumed by core's program image */
extern unsigned _prog_img_beg, _prog_img_end;
/* physical address range occupied by core */
extern addr_t _vma_start, _lma_start;
/**************************
** Boot-module handling **
**************************/
/**
* Scan ROM module image for boot modules
*
* By convention, the boot modules start at the page after core's BSS segment.
*/
int Platform::_init_rom_fs()
{
/**
* Format of module meta-data as found in the ROM module image
*/
struct Module
{
long name; /* physical address of null-terminated string */
long base; /* physical address of module data */
long size; /* size of module data in bytes */
};
/* find base address of ROM module image */
addr_t phys_base = round_page((addr_t)&_prog_img_end);
/* map the first page of the image containing the module meta data */
class Out_of_virtual_memory_during_rom_fs_init { };
void *virt_base = 0;
if (!_core_mem_alloc.virt_alloc()->alloc(get_page_size(), &virt_base))
throw Out_of_virtual_memory_during_rom_fs_init();
if (!map_local(phys_base, (addr_t)virt_base, 1)) {
PERR("map_local failed");
return -1;
}
/* remove page containing module infos from physical memory allocator */
_core_mem_alloc.phys_alloc()->remove_range(phys_base, get_page_size());
/* validate the presence of a ROM image by checking the magic cookie */
const char cookie[4] = {'G', 'R', 'O', 'M'};
for (size_t i = 0; i < sizeof(cookie); i++)
if (cookie[i] != ((char *)virt_base)[i]) {
PERR("could not detect ROM modules");
return -2;
}
printf("detected ROM module image at 0x%p\n", (void *)phys_base);
/* detect overly large meta data, we only support 4K */
addr_t end_of_header = ((long *)virt_base)[1];
size_t header_size = end_of_header - (long)phys_base;
if (header_size > get_page_size()) {
PERR("ROM fs module header exceeds %d bytes", get_page_size());
return -3;
}
/* start of module list */
Module *module = (Module *)((addr_t)virt_base + 2*sizeof(long));
/*
* Interate over module list and populate core's ROM file system with
* 'Rom_module' objects.
*/
for (; module->name; module++) {
/* convert physical address of module name to core-local address */
char *name = (char *)(module->name - phys_base + (addr_t)virt_base);
printf("ROM module \"%s\" at physical address 0x%p, size=%zd\n",
name, (void *)module->base, (size_t)module->size);
Rom_module *rom_module = new (core_mem_alloc())
Rom_module(module->base, module->size, name);
_rom_fs.insert(rom_module);
/* remove module from physical memory allocator */
_core_mem_alloc.phys_alloc()->remove_range(module->base, round_page(module->size));
}
return 0;
}
/****************************************
** Support for core memory management **
****************************************/
bool Core_mem_allocator::Mapped_mem_allocator::_map_local(addr_t virt_addr, addr_t phys_addr, unsigned size_log2)
{
return map_local(phys_addr, virt_addr, 1 << (size_log2 - get_page_size_log2()));
}
/************************
** Platform interface **
************************/
Platform::Platform() :
_io_mem_alloc(core_mem_alloc()), _io_port_alloc(core_mem_alloc()),
_irq_alloc(core_mem_alloc()), _vm_base(0), _vm_size(0)
{
using namespace Codezero;
/* init core UTCB */
static char main_utcb[PAGE_SIZE] __attribute__((aligned(PAGE_SIZE)));
static struct exregs_data exregs;
exregs_set_utcb(&exregs, (unsigned long)&main_utcb[0]);
l4_exchange_registers(&exregs, thread_myself());
/* error handling is futile at this point */
/* read number of capabilities */
int num_caps;
int ret;
if ((ret = l4_capability_control(CAP_CONTROL_NCAPS,
0, &num_caps)) < 0) {
PERR("l4_capability_control(CAP_CONTROL_NCAPS) returned %d", ret);
class Could_not_obtain_num_of_capabilities { };
throw Could_not_obtain_num_of_capabilities();
}
struct capability cap_array[num_caps];
if (verbose_boot_info)
printf("allocated cap array[%d] of size %d on stack\n",
num_caps, sizeof(cap_array));
/* read all capabilities */
if ((ret = l4_capability_control(CAP_CONTROL_READ,
0, cap_array)) < 0) {
PERR("l4_capability_control(CAP_CONTROL_READ) returned %d", ret);
class Read_caps_failed { };
throw Read_caps_failed();
}
/* initialize core allocators */
bool phys_mem_defined = false;
addr_t dev_mem_base = 0;
for (int i = 0; i < num_caps; i++) {
struct capability *cap = &cap_array[i];
addr_t base = cap->start << get_page_size_log2(),
size = cap->size << get_page_size_log2();
if (verbose_boot_info)
printf("cap type=%x, rtype=%x, base=%lx, size=%lx\n",
cap_type(cap), cap_rtype(cap), base, size);
switch (cap_type(cap)) {
case CAP_TYPE_MAP_VIRTMEM:
/*
* Use first non-UTCB virtual address range as default
* virtual memory range usable for all processes.
*/
if (_vm_size == 0) {
/* exclude page at virtual address 0 */
if (base == 0 && size >= get_page_size()) {
base += get_page_size();
size -= get_page_size();
}
_vm_base = base;
_vm_size = size;
/* add range as free range to core's virtual address allocator */
_core_mem_alloc.virt_alloc()->add_range(base, size);
break;
}
PWRN("ignoring additional virtual address range [%lx,%lx)",
base, base + size);
break;
case CAP_TYPE_MAP_PHYSMEM:
/*
* We interpret the first physical memory resource that is bigger
* than typical device resources as RAM.
*/
enum { RAM_SIZE_MIN = 16*1024*1024 };
if (!phys_mem_defined && size > RAM_SIZE_MIN) {
_core_mem_alloc.phys_alloc()->add_range(base, size);
phys_mem_defined = true;
dev_mem_base = base + size;
}
break;
case CAP_TYPE_IPC:
case CAP_TYPE_UMUTEX:
case CAP_TYPE_IRQCTRL:
case CAP_TYPE_QUANTITY:
break;
}
}
addr_t core_virt_beg = trunc_page((addr_t)&_prog_img_beg),
core_virt_end = round_page((addr_t)&_prog_img_end);
size_t core_size = core_virt_end - core_virt_beg;
printf("core image:\n");
printf(" virtual address range [%08lx,%08lx) size=0x%zx\n",
core_virt_beg, core_virt_end, core_size);
printf(" physically located at 0x%08lx\n", _lma_start);
/* remove core image from core's virtual address allocator */
_core_mem_alloc.virt_alloc()->remove_range(core_virt_beg, core_size);
/* preserve context area in core's virtual address space */
_core_mem_alloc.virt_alloc()->raw()->remove_range(Thread_base::CONTEXT_AREA_VIRTUAL_BASE,
Thread_base::CONTEXT_AREA_VIRTUAL_SIZE);
/* remove used core memory from physical memory allocator */
_core_mem_alloc.phys_alloc()->remove_range(_lma_start, core_size);
/* remove magically mapped UART from core virtual memory */
_core_mem_alloc.virt_alloc()->remove_range(USERSPACE_CONSOLE_VBASE, get_page_size());
/* add boot modules to ROM fs */
if (_init_rom_fs() < 0) {
PERR("initialization of romfs failed - halt.");
while(1);
}
/* initialize interrupt allocator */
_irq_alloc.add_range(0, 255);
/* regard physical addresses higher than memory area as MMIO */
_io_mem_alloc.add_range(dev_mem_base, 0x80000000 - dev_mem_base);
/*
* Print statistics about allocator initialization
*/
printf("VM area at [%08lx,%08lx)\n", _vm_base, _vm_base + _vm_size);
if (verbose_boot_info) {
printf(":phys_alloc: "); _core_mem_alloc.phys_alloc()->raw()->dump_addr_tree();
printf(":virt_alloc: "); _core_mem_alloc.virt_alloc()->raw()->dump_addr_tree();
printf(":io_mem_alloc: "); _io_mem_alloc.raw()->dump_addr_tree();
}
}
void Platform::wait_for_exit()
{
sleep_forever();
}
void Core_parent::exit(int exit_value) { }