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
|
// Copyright 2025 syzkaller project authors. All rights reserved.
// Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file.
package generated
import (
"bytes"
"compress/flate"
"embed"
"encoding/gob"
"fmt"
"path/filepath"
"github.com/google/syzkaller/prog"
"github.com/google/syzkaller/sys/targets"
)
type Desc struct {
Syscalls []*prog.Syscall
Resources []*prog.ResourceDesc
Consts []prog.ConstValue
Flags []prog.FlagDesc
Types []prog.Type
}
func Register(os, arch, revision string, init func(*prog.Target), files embed.FS) {
// Does not call targets.Get b/c it does slow lazy initialization of targets.
sysTarget := targets.List[os][arch]
target := &prog.Target{
OS: os,
Arch: arch,
Revision: revision,
PtrSize: sysTarget.PtrSize,
PageSize: sysTarget.PageSize,
NumPages: sysTarget.NumPages,
DataOffset: sysTarget.DataOffset,
BigEndian: sysTarget.BigEndian,
}
filler := func(target *prog.Target) {
fill(target, files)
}
prog.RegisterTarget(target, filler, init)
}
func fill(target *prog.Target, files embed.FS) {
data, err := files.ReadFile(FileName(target.OS, target.Arch))
if err != nil {
panic(err)
}
desc := new(Desc)
if err := gob.NewDecoder(flate.NewReader(bytes.NewReader(data))).Decode(desc); err != nil {
panic(err)
}
target.Syscalls = desc.Syscalls
target.Resources = desc.Resources
target.Consts = desc.Consts
target.Flags = desc.Flags
target.Types = desc.Types
}
func Serialize(desc *Desc) ([]byte, error) {
out := new(bytes.Buffer)
compressor, err := flate.NewWriter(out, flate.DefaultCompression)
if err != nil {
return nil, err
}
enc := gob.NewEncoder(compressor)
if err := enc.Encode(desc); err != nil {
return nil, err
}
if err := compressor.Close(); err != nil {
return nil, err
}
return out.Bytes(), nil
}
func FileName(os, arch string) string {
return fileName(fmt.Sprintf("%v_%v", os, arch))
}
func Glob() string {
return fileName("*")
}
func fileName(name string) string {
return filepath.Join("gen", fmt.Sprintf("%v.gob.flate", name))
}
func init() {
gob.Register(prog.Ref(0))
gob.Register(&prog.ResourceType{})
gob.Register(&prog.ConstType{})
gob.Register(&prog.IntType{})
gob.Register(&prog.FlagsType{})
gob.Register(&prog.LenType{})
gob.Register(&prog.ProcType{})
gob.Register(&prog.CsumType{})
gob.Register(&prog.VmaType{})
gob.Register(&prog.BufferType{})
gob.Register(&prog.ArrayType{})
gob.Register(&prog.PtrType{})
gob.Register(&prog.StructType{})
gob.Register(&prog.UnionType{})
gob.Register(&prog.BinaryExpression{})
gob.Register(&prog.Value{})
}
|
