forked from u-root/u-root
-
Notifications
You must be signed in to change notification settings - Fork 0
/
description.go
127 lines (108 loc) · 2.75 KB
/
description.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
// Copyright 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
import (
"bytes"
"crypto/sha256"
"encoding/json"
"fmt"
"strconv"
"strings"
)
const DebugPrefix = "MULTIBOOT_DEBUG_INFO:"
// Description stores representation of multiboot
// information passed to a final kernel used for
// for debugging and testing.
type Description struct {
Status string `json:"status"`
Flags uint32 `json:"flags"`
MemLower uint32 `json:"mem_lower"`
MemUpper uint32 `json:"mem_upper"`
MmapAddr uint32 `json:"mmap_addr"`
MmapLength uint32 `json:"mmap_length"`
CmdLine string `json:"cmdline"`
Bootloader string `json:"bootloader"`
Mmap []MemoryMap `json:"mmap"`
Modules []ModuleDesc `json:"modules"`
}
// Description returns string representation of
// multiboot information.
func (m multiboot) description() (string, error) {
var modules []ModuleDesc
for i, mod := range m.loadedModules {
name := strings.Fields(m.modules[i])[0]
b, err := readFile(name)
if err != nil {
return "", nil
}
hash := sha256.Sum256(b)
modules = append(modules, ModuleDesc{
Start: mod.Start,
End: mod.End,
CmdLine: m.modules[i],
SHA256: fmt.Sprintf("%x", hash),
})
}
b, err := json.Marshal(Description{
Status: "ok",
Flags: uint32(m.info.Flags),
MemLower: m.info.MemLower,
MemUpper: m.info.MemUpper,
MmapAddr: m.info.MmapAddr,
MmapLength: m.info.MmapLength,
CmdLine: m.cmdLine,
Bootloader: m.bootloader,
Mmap: m.memoryMap(),
Modules: modules,
})
if err != nil {
return "", err
}
b = bytes.Replace(b, []byte{'\n'}, []byte{' '}, -1)
return string(b), nil
}
// ModuleDesc is a debug representation of
// loaded module.
type ModuleDesc struct {
Start uint32 `json:"start"`
End uint32 `json:"end"`
CmdLine string `json:"cmdline"`
SHA256 string `json:"sha256"`
}
type mmap struct {
Size uint32 `json:"size"`
BaseAddr string `json:"base_addr"`
Length string `json:"length"`
Type uint32 `json:"type"`
}
// MarshalJSON implements json.Marshaler
func (m MemoryMap) MarshalJSON() ([]byte, error) {
return json.Marshal(mmap{
Size: m.Size,
BaseAddr: fmt.Sprintf("%#x", m.BaseAddr),
Length: fmt.Sprintf("%#x", m.Length),
Type: m.Type,
})
}
// UnmarshalJSON implements json.Unmarshaler
func (m *MemoryMap) UnmarshalJSON(b []byte) error {
var desc mmap
err := json.Unmarshal(b, &desc)
if err != nil {
return err
}
m.Size = desc.Size
m.Type = desc.Type
v, err := strconv.ParseUint(desc.BaseAddr, 0, 64)
if err != nil {
return err
}
m.BaseAddr = v
v, err = strconv.ParseUint(desc.Length, 0, 64)
if err != nil {
return err
}
m.Length = v
return nil
}