forked from u-root/u-root
/
multiboot.go
383 lines (337 loc) · 9.89 KB
/
multiboot.go
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
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
// Copyright 2018-2019 the u-root Authors. All rights reserved
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package multiboot implements bootloading multiboot kernels as defined by
// https://www.gnu.org/software/grub/manual/multiboot/multiboot.html.
//
// Package multiboot crafts kexec segments that can be used with the kexec_load
// system call.
package multiboot
import (
"bytes"
"debug/elf"
"encoding/binary"
"fmt"
"io"
"log"
"os"
"path/filepath"
"strings"
"github.com/u-root/u-root/pkg/ibft"
"github.com/u-root/u-root/pkg/kexec"
"github.com/u-root/u-root/pkg/multiboot/internal/trampoline"
"github.com/u-root/u-root/pkg/ubinary"
)
const bootloader = "u-root kexec"
// multiboot defines parameters for working with multiboot kernels.
type multiboot struct {
mem kexec.Memory
file string
modules []string
cmdLine string
bootloader string
// trampoline is a path to an executable blob, which contains a trampoline segment.
// Trampoline sets machine to a specific state defined by multiboot v1 spec.
// https://www.gnu.org/software/grub/manual/multiboot/multiboot.html#Machine-state.
trampoline string
header header
// infoAddr is a pointer to multiboot info.
infoAddr uintptr
// kernelEntry is a pointer to entry point of kernel.
kernelEntry uintptr
// EntryPoint is a pointer to trampoline.
entryPoint uintptr
info info
loadedModules []module
}
var (
rangeTypes = map[kexec.RangeType]uint32{
kexec.RangeRAM: 1,
kexec.RangeDefault: 2,
kexec.RangeACPI: 3,
kexec.RangeNVS: 4,
kexec.RangeReserved: 2,
}
PageSize = os.Getpagesize()
)
var sizeofMemoryMap = uint(binary.Size(MemoryMap{}))
// MemoryMap represents a reserved range of memory passed via the multiboot Info header.
type MemoryMap struct {
// Size is the size of the associated structure in bytes.
Size uint32
// BaseAddr is the starting address.
BaseAddr uint64
// Length is the size of the memory region in bytes.
Length uint64
// Type is the variety of address range represented.
Type uint32
}
// String returns a readable representation of a MemoryMap entry.
func (m MemoryMap) String() string {
return fmt.Sprintf("[0x%x, 0x%x) (len: 0x%x, size: 0x%x, type: %d)", m.BaseAddr, m.BaseAddr+m.Length, m.Length, m.Size, m.Type)
}
type memoryMaps []MemoryMap
// String returns a new-line-separated representation of the entire memory map.
func (m memoryMaps) String() string {
var s []string
for _, mm := range m {
s = append(s, mm.String())
}
return strings.Join(s, "\n")
}
// Probe checks if file is multiboot v1 kernel.
func Probe(file string) error {
b, err := readFile(file)
if err != nil {
return err
}
kernel := &kernelReader{buf: b}
_, err = parseHeader(kernel)
return err
}
// newMB returns a new multiboot instance.
func newMB(file, cmdLine string, modules []string) (*multiboot, error) {
// Trampoline should be a part of current binary.
p, err := os.Executable()
if err != nil {
return nil, fmt.Errorf("Cannot find current executable path: %v", err)
}
trampoline, err := filepath.EvalSymlinks(p)
if err != nil {
return nil, fmt.Errorf("Cannot eval symlinks for %v: %v", p, err)
}
return &multiboot{
file: file,
modules: modules,
cmdLine: cmdLine,
trampoline: trampoline,
bootloader: bootloader,
mem: kexec.Memory{},
}, nil
}
// Load parses and loads a multiboot kernel `file` using kexec_load.
//
// Each module is a path followed by optional command-line arguments, e.g.
// []string{"./module arg1 arg2", "./module2 arg3 arg4"}.
//
// debug turns on debug logging.
//
// Load can set up an arbitrary number of modules, and takes care of the
// multiboot info structure, including the memory map.
//
// After Load is called, kexec.Reboot() is ready to be called any time to stop
// Linux and execute the loaded kernel.
func Load(debug bool, file, cmdline string, modules []string, ibft *ibft.IBFT) error {
m, err := newMB(file, cmdline, modules)
if err != nil {
return err
}
if err := m.load(debug, ibft); err != nil {
return err
}
if err := kexec.Load(m.entryPoint, m.mem.Segments, 0); err != nil {
return fmt.Errorf("kexec.Load() error: %v", err)
}
return nil
}
// load loads and parses multiboot information from m.file.
func (m *multiboot) load(debug bool, ibft *ibft.IBFT) error {
log.Printf("Parsing file %v", m.file)
b, err := readFile(m.file)
if err != nil {
return err
}
kernel := kernelReader{buf: b}
log.Println("Parsing multiboot header")
if m.header, err = parseHeader(&kernel); err != nil {
return fmt.Errorf("error parsing headers: %v", err)
}
log.Printf("Getting kernel entry point")
if m.kernelEntry, err = getEntryPoint(kernel); err != nil {
return fmt.Errorf("error getting kernel entry point: %v", err)
}
log.Printf("Kernel entry point at %#x", m.kernelEntry)
log.Printf("Parsing ELF segments")
if err := m.mem.LoadElfSegments(kernel); err != nil {
return fmt.Errorf("error loading ELF segments: %v", err)
}
log.Printf("Parsing memory map")
if err := m.mem.ParseMemoryMap(); err != nil {
return fmt.Errorf("error parsing memory map: %v", err)
}
// Insert the iBFT now, since nothing else has been allocated and this
// is the most restricted allocation we're gonna have to make.
if ibft != nil {
ibuf := ibft.Marshal()
// The iBFT may sit between 512K and 1M in physical memory. The
// loaded OS finds it by scanning this region.
allowedRange := kexec.Range{
Start: 0x80000,
Size: 0x80000,
}
r, err := m.mem.ReservePhys(uint(len(ibuf)), allowedRange)
if err != nil {
return fmt.Errorf("reserving space for the iBFT in %s failed: %v", allowedRange, err)
}
log.Printf("iBFT was allocated at %s: %#v", r, ibft)
m.mem.Segments.Insert(kexec.NewSegment(ibuf, r))
}
log.Printf("Preparing multiboot info")
if m.infoAddr, err = m.addInfo(); err != nil {
return fmt.Errorf("error preparing multiboot info: %v", err)
}
log.Printf("Adding trampoline")
if m.entryPoint, err = m.addTrampoline(); err != nil {
return fmt.Errorf("error adding trampoline: %v", err)
}
log.Printf("Trampoline entry point at %#x", m.entryPoint)
if debug {
info, err := m.description()
if err != nil {
log.Printf("%v cannot create debug info: %v", DebugPrefix, err)
}
log.Printf("%v %v", DebugPrefix, info)
}
return nil
}
func getEntryPoint(r io.ReaderAt) (uintptr, error) {
f, err := elf.NewFile(r)
if err != nil {
return 0, err
}
return uintptr(f.Entry), err
}
func (m *multiboot) addInfo() (addr uintptr, err error) {
iw, err := m.newMultibootInfo()
if err != nil {
return 0, err
}
infoSize, err := iw.size()
if err != nil {
return 0, err
}
r, err := m.mem.FindSpace(infoSize)
if err != nil {
return 0, err
}
d, err := iw.marshal(r.Start)
if err != nil {
return 0, err
}
m.info = iw.info
m.mem.Segments.Insert(kexec.NewSegment(d, r))
return r.Start, nil
}
func (m multiboot) memoryMap() memoryMaps {
var ret memoryMaps
for _, r := range m.mem.Phys {
typ, ok := rangeTypes[r.Type]
if !ok {
typ = rangeTypes[kexec.RangeDefault]
}
v := MemoryMap{
// Size is really used for skipping to the next pair.
Size: uint32(sizeofMemoryMap) - 4,
BaseAddr: uint64(r.Start),
Length: uint64(r.Size),
Type: typ,
}
ret = append(ret, v)
}
return ret
}
func (m *multiboot) addMmap() (addr uintptr, size uint, err error) {
mmap := m.memoryMap()
log.Printf("Memory map:\n%s", mmap)
d, err := mmap.marshal()
if err != nil {
return 0, 0, err
}
r, err := m.mem.AddKexecSegment(d)
if err != nil {
return 0, 0, err
}
return r.Start, uint(len(mmap)) * sizeofMemoryMap, nil
}
func (m multiboot) memoryBoundaries() (lower, upper uint32) {
const M1 = 1048576
const K640 = 640 * 1024
for _, r := range m.mem.Phys {
if r.Type != kexec.RangeRAM {
continue
}
end := uint32(r.Start) + uint32(r.Size)
// Lower memory starts at address 0, and upper memory starts at address 1 megabyte.
// The maximum possible value for lower memory is 640 kilobytes.
// The value returned for upper memory is maximally the address of the first upper memory hole minus 1 megabyte.
// It is not guaranteed to be this value.
if r.Start <= K640 && end > lower {
lower = end
}
if r.Start <= M1 && end > upper+M1 {
upper = end - M1
}
}
return
}
func min(a, b uint32) uint32 {
if a < b {
return a
}
return b
}
func (m *multiboot) newMultibootInfo() (*infoWrapper, error) {
mmapAddr, mmapSize, err := m.addMmap()
if err != nil {
return nil, err
}
var inf info
if m.header.Flags&flagHeaderMemoryInfo != 0 {
lower, upper := m.memoryBoundaries()
inf = info{
Flags: flagInfoMemMap | flagInfoMemory,
MemLower: min(uint32(lower>>10), 0xFFFFFFFF),
MemUpper: min(uint32(upper>>10), 0xFFFFFFFF),
MmapLength: uint32(mmapSize),
MmapAddr: uint32(mmapAddr),
}
}
if len(m.modules) > 0 {
modAddr, err := m.addModules()
if err != nil {
return nil, err
}
inf.Flags |= flagInfoMods
inf.ModsAddr = uint32(modAddr)
inf.ModsCount = uint32(len(m.modules))
}
inf.CmdLine = sizeofInfo
inf.BootLoaderName = sizeofInfo + uint32(len(m.cmdLine)) + 1
inf.Flags |= flagInfoCmdLine | flagInfoBootLoaderName
return &infoWrapper{
info: inf,
CmdLine: m.cmdLine,
BootLoaderName: m.bootloader,
}, nil
}
// marshal writes out the exact bytes expected by the multiboot info header
// specified in
// https://www.gnu.org/software/grub/manual/multiboot/multiboot.html#Boot-information-format.
func (m memoryMaps) marshal() ([]byte, error) {
buf := bytes.Buffer{}
err := binary.Write(&buf, ubinary.NativeEndian, m)
return buf.Bytes(), err
}
func (m *multiboot) addTrampoline() (entry uintptr, err error) {
// Trampoline setups the machine registers to desired state
// and executes the loaded kernel.
d, err := trampoline.Setup(m.trampoline, m.infoAddr, m.kernelEntry)
if err != nil {
return 0, err
}
r, err := m.mem.AddKexecSegment(d)
if err != nil {
return 0, err
}
return r.Start, nil
}