Source file
src/runtime/vdso_linux.go
Documentation: runtime
1
2
3
4
5
6
7
8
9 package runtime
10
11 import "unsafe"
12
13
14
15
16
17
18
19
20
21
22
23
24 const (
25 _AT_SYSINFO_EHDR = 33
26
27 _PT_LOAD = 1
28 _PT_DYNAMIC = 2
29
30 _DT_NULL = 0
31 _DT_HASH = 4
32 _DT_STRTAB = 5
33 _DT_SYMTAB = 6
34 _DT_GNU_HASH = 0x6ffffef5
35 _DT_VERSYM = 0x6ffffff0
36 _DT_VERDEF = 0x6ffffffc
37
38 _VER_FLG_BASE = 0x1
39
40 _SHN_UNDEF = 0
41
42 _SHT_DYNSYM = 11
43
44 _STT_FUNC = 2
45
46 _STT_NOTYPE = 0
47
48 _STB_GLOBAL = 1
49 _STB_WEAK = 2
50
51 _EI_NIDENT = 16
52
53
54
55 vdsoSymTabSize = vdsoArrayMax / unsafe.Sizeof(elfSym{})
56 vdsoDynSize = vdsoArrayMax / unsafe.Sizeof(elfDyn{})
57 vdsoSymStringsSize = vdsoArrayMax
58 vdsoVerSymSize = vdsoArrayMax / 2
59 vdsoHashSize = vdsoArrayMax / 4
60
61
62
63 vdsoBloomSizeScale = unsafe.Sizeof(uintptr(0)) / 4
64 )
65
66
67 func _ELF_ST_BIND(val byte) byte { return val >> 4 }
68 func _ELF_ST_TYPE(val byte) byte { return val & 0xf }
69
70 type vdsoSymbolKey struct {
71 name string
72 symHash uint32
73 gnuHash uint32
74 ptr *uintptr
75 }
76
77 type vdsoVersionKey struct {
78 version string
79 verHash uint32
80 }
81
82 type vdsoInfo struct {
83 valid bool
84
85
86 loadAddr uintptr
87 loadOffset uintptr
88
89
90 symtab *[vdsoSymTabSize]elfSym
91 symstrings *[vdsoSymStringsSize]byte
92 chain []uint32
93 bucket []uint32
94 symOff uint32
95 isGNUHash bool
96
97
98 versym *[vdsoVerSymSize]uint16
99 verdef *elfVerdef
100 }
101
102
103
104 func vdsoInitFromSysinfoEhdr(info *vdsoInfo, hdr *elfEhdr) {
105 info.valid = false
106 info.loadAddr = uintptr(unsafe.Pointer(hdr))
107
108 pt := unsafe.Pointer(info.loadAddr + uintptr(hdr.e_phoff))
109
110
111
112 var foundVaddr bool
113 var dyn *[vdsoDynSize]elfDyn
114 for i := uint16(0); i < hdr.e_phnum; i++ {
115 pt := (*elfPhdr)(add(pt, uintptr(i)*unsafe.Sizeof(elfPhdr{})))
116 switch pt.p_type {
117 case _PT_LOAD:
118 if !foundVaddr {
119 foundVaddr = true
120 info.loadOffset = info.loadAddr + uintptr(pt.p_offset-pt.p_vaddr)
121 }
122
123 case _PT_DYNAMIC:
124 dyn = (*[vdsoDynSize]elfDyn)(unsafe.Pointer(info.loadAddr + uintptr(pt.p_offset)))
125 }
126 }
127
128 if !foundVaddr || dyn == nil {
129 return
130 }
131
132
133
134 var hash, gnuhash *[vdsoHashSize]uint32
135 info.symstrings = nil
136 info.symtab = nil
137 info.versym = nil
138 info.verdef = nil
139 for i := 0; dyn[i].d_tag != _DT_NULL; i++ {
140 dt := &dyn[i]
141 p := info.loadOffset + uintptr(dt.d_val)
142 switch dt.d_tag {
143 case _DT_STRTAB:
144 info.symstrings = (*[vdsoSymStringsSize]byte)(unsafe.Pointer(p))
145 case _DT_SYMTAB:
146 info.symtab = (*[vdsoSymTabSize]elfSym)(unsafe.Pointer(p))
147 case _DT_HASH:
148 hash = (*[vdsoHashSize]uint32)(unsafe.Pointer(p))
149 case _DT_GNU_HASH:
150 gnuhash = (*[vdsoHashSize]uint32)(unsafe.Pointer(p))
151 case _DT_VERSYM:
152 info.versym = (*[vdsoVerSymSize]uint16)(unsafe.Pointer(p))
153 case _DT_VERDEF:
154 info.verdef = (*elfVerdef)(unsafe.Pointer(p))
155 }
156 }
157
158 if info.symstrings == nil || info.symtab == nil || (hash == nil && gnuhash == nil) {
159 return
160 }
161
162 if info.verdef == nil {
163 info.versym = nil
164 }
165
166 if gnuhash != nil {
167
168 nbucket := gnuhash[0]
169 info.symOff = gnuhash[1]
170 bloomSize := gnuhash[2]
171 info.bucket = gnuhash[4+bloomSize*uint32(vdsoBloomSizeScale):][:nbucket]
172 info.chain = gnuhash[4+bloomSize*uint32(vdsoBloomSizeScale)+nbucket:]
173 info.isGNUHash = true
174 } else {
175
176 nbucket := hash[0]
177 nchain := hash[1]
178 info.bucket = hash[2 : 2+nbucket]
179 info.chain = hash[2+nbucket : 2+nbucket+nchain]
180 }
181
182
183 info.valid = true
184 }
185
186 func vdsoFindVersion(info *vdsoInfo, ver *vdsoVersionKey) int32 {
187 if !info.valid {
188 return 0
189 }
190
191 def := info.verdef
192 for {
193 if def.vd_flags&_VER_FLG_BASE == 0 {
194 aux := (*elfVerdaux)(add(unsafe.Pointer(def), uintptr(def.vd_aux)))
195 if def.vd_hash == ver.verHash && ver.version == gostringnocopy(&info.symstrings[aux.vda_name]) {
196 return int32(def.vd_ndx & 0x7fff)
197 }
198 }
199
200 if def.vd_next == 0 {
201 break
202 }
203 def = (*elfVerdef)(add(unsafe.Pointer(def), uintptr(def.vd_next)))
204 }
205
206 return -1
207 }
208
209 func vdsoParseSymbols(info *vdsoInfo, version int32) {
210 if !info.valid {
211 return
212 }
213
214 apply := func(symIndex uint32, k vdsoSymbolKey) bool {
215 sym := &info.symtab[symIndex]
216 typ := _ELF_ST_TYPE(sym.st_info)
217 bind := _ELF_ST_BIND(sym.st_info)
218
219 if typ != _STT_FUNC && typ != _STT_NOTYPE || bind != _STB_GLOBAL && bind != _STB_WEAK || sym.st_shndx == _SHN_UNDEF {
220 return false
221 }
222 if k.name != gostringnocopy(&info.symstrings[sym.st_name]) {
223 return false
224 }
225
226 if info.versym != nil && version != 0 && int32(info.versym[symIndex]&0x7fff) != version {
227 return false
228 }
229
230 *k.ptr = info.loadOffset + uintptr(sym.st_value)
231 return true
232 }
233
234 if !info.isGNUHash {
235
236 for _, k := range vdsoSymbolKeys {
237 for chain := info.bucket[k.symHash%uint32(len(info.bucket))]; chain != 0; chain = info.chain[chain] {
238 if apply(chain, k) {
239 break
240 }
241 }
242 }
243 return
244 }
245
246
247 for _, k := range vdsoSymbolKeys {
248 symIndex := info.bucket[k.gnuHash%uint32(len(info.bucket))]
249 if symIndex < info.symOff {
250 continue
251 }
252 for ; ; symIndex++ {
253 hash := info.chain[symIndex-info.symOff]
254 if hash|1 == k.gnuHash|1 {
255
256 if apply(symIndex, k) {
257 break
258 }
259 }
260 if hash&1 != 0 {
261
262 break
263 }
264 }
265 }
266 }
267
268 func vdsoauxv(tag, val uintptr) {
269 switch tag {
270 case _AT_SYSINFO_EHDR:
271 if val == 0 {
272
273 return
274 }
275 var info vdsoInfo
276
277
278 info1 := (*vdsoInfo)(noescape(unsafe.Pointer(&info)))
279 vdsoInitFromSysinfoEhdr(info1, (*elfEhdr)(unsafe.Pointer(val)))
280 vdsoParseSymbols(info1, vdsoFindVersion(info1, &vdsoLinuxVersion))
281 }
282 }
283
284
285
286 func inVDSOPage(pc uintptr) bool {
287 for _, k := range vdsoSymbolKeys {
288 if *k.ptr != 0 {
289 page := *k.ptr &^ (physPageSize - 1)
290 return pc >= page && pc < page+physPageSize
291 }
292 }
293 return false
294 }
295
View as plain text