GoSudaDirecte Linux-systeemaanroepen in puur Go met syscall.Syscall en unsafe.Pointer
Samenvatting
We zullen leren over directe systeemaanroepen in Go. Aangezien Go strikte compilerfouten en een rigide GC biedt, is het veel beter om laag-niveau aanroepen te vervangen door Pure Go. Gelukkig zijn de meeste C-functieaanroepen volledig opnieuw geïmplementeerd in Go, op een goede en hedendaagse manier. Laten we er eens naar kijken.
Systeemaanroep
Een systeemaanroep is een directe aanvraag aan het besturingssysteem. Aangezien het systeem doorgaans is geschreven in een rigide, ouderwetse stijl omdat het rechtstreeks op de hardware draait, moeten we er rekening mee houden dat de aanroep een strikte en correcte vorm van aanvraag moet aanleveren. Dus, zelfs als we sommige variabelen niet nodig hebben, moeten we toch de grootte invullen, ongeacht het gebruik. Laten we dit controleren met een volledig werkend voorbeeld.
Volledig voorbeeld
1package main
2import (
3 "fmt"
4 "syscall"
5 "unsafe"
6)
7
8type sysinfo_t struct {
9 Uptime int64
10 Loads [3]uint64
11 Totalram uint64
12 Freeram uint64
13 Sharedram uint64
14 Bufferram uint64
15 Totalswap uint64
16 Freeswap uint64
17 Procs uint16
18 Pad uint16
19 _ [4]byte
20 Totalhigh uint64
21 Freehigh uint64
22 MemUnit uint32
23 _ [4]byte
24}
25
26func main() {
27 var info sysinfo_t
28 _, _, errno := syscall.Syscall(syscall.SYS_SYSINFO, uintptr(unsafe.Pointer(&info)), 0, 0)
29 if errno != 0 {
30 fmt.Println("sysinfo syscall failed:", errno)
31 return
32 }
33
34 scale := float64(1 << 16)
35 fmt.Printf("Uptime: %d seconds\n", info.Uptime)
36 fmt.Printf("Load Average: %.2f %.2f %.2f\n",
37 float64(info.Loads[0])/scale,
38 float64(info.Loads[1])/scale,
39 float64(info.Loads[2])/scale)
40 fmt.Printf("Memory: total=%d MB free=%d MB buffer=%d MB\n",
41 info.Totalram*uint64(info.MemUnit)/1024/1024,
42 info.Freeram*uint64(info.MemUnit)/1024/1024,
43 info.Bufferram*uint64(info.MemUnit)/1024/1024)
44 fmt.Printf("Swap: total=%d MB free=%d MB\n",
45 info.Totalswap*uint64(info.MemUnit)/1024/1024,
46 info.Freeswap*uint64(info.MemUnit)/1024/1024)
47 fmt.Printf("Processes: %d\n", info.Procs)
48}
Dit voorbeeld bevat alle variabelen en drukt uitgebreide informatie over de huidige systeeminformatie af.
We kunnen deze code vergelijken met een slot en een sleutel.syscall.SYS_SYSINFO is een sleutel die een slot ontgrendelt dat zich in een kernel bevindt.
Daarom is het belangrijk om de juiste sleutel voor het slot te gebruiken.
Wat gebeurt er als we syscall.SYS_GETPID voor deze aanroep gebruiken?
Dit is een sleutel voor een slot dat een proces-ID bevat.
Dit zal proberen een PID op te halen uit een ruimte voor systeeminformatie.
Als gevolg hiervan kan geen enkele informatie correct worden gelezen; de aanroep moet als mislukt worden teruggegeven.
Nu moeten we weten welke onderdelen er zijn opgenomen en hoe de onderdelen zijn geordend. In de eerste sleuf van een slot hebben we Uptime, met een grootte van 2^64. Als we dit proberen te lezen met 2^32, wordt de bitreeks niet volledig gelezen. We kunnen dergelijke gedeeltelijke binaire gegevens niet gebruiken, tenzij we laag-niveau trucs gaan schrijven.
Na het lezen van 64 bits aan binaire gegevens komen we eindelijk bij een tweede sleuf. Deze kan alleen nauwkeurig worden gelezen wanneer we het vorige 64-bits gehele getal hebben gelezen.
Door deze strikte en logische stappen herhaaldelijk uit te voeren, om de juiste informatie uit een systeem te verkrijgen, kunnen we de gelezen gegevens correct verwerken.
Hoe 'variabelenamen' over te slaan
Hoewel we variabelen zelf niet kunnen 'overslaan', is het belangrijk om gebruikte variabelen van weggegooide variabelen te onderscheiden. Als het doel van het programma duidelijk genoeg is, is het beter om naamloze variabelen als plaatshouders te gebruiken dan elke waarde te labelen, zelfs als ze niet voor altijd worden gebruikt. Laten we dit controleren met een voorbeeld, "Free Memory Checker"
Voorbeeld - Free Memory Checker
Bij het controleren van vrij geheugen/swap hebben we geen andere informatie nodig die op verschillende bronnen wijst. Om een betere overzichtelijkheid te bereiken, kun je anonieme variabelen maken om specifieke ruimtes vast te houden.
1package main
2
3import (
4 "fmt"
5 "syscall"
6 "unsafe"
7)
8
9type sysinfo_t struct {
10 _ int64
11 _ [3]uint64
12 Totalram uint64
13 Freeram uint64
14 Sharedram uint64
15 Bufferram uint64
16 Totalswap uint64
17 Freeswap uint64
18 _ uint16 // anoniem, en ongebruikte velden worden gemarkeerd als _
19 _ uint16
20 _ [4]byte
21 _ uint64
22 _ uint64
23 MemUnit uint32
24 _ [4]byte
25}
26
27func main() {
28 var info sysinfo_t
29 _, _, errno := syscall.Syscall(syscall.SYS_SYSINFO, uintptr(unsafe.Pointer(&info)), 0, 0)
30 if errno != 0 {
31 fmt.Println("sysinfo syscall failed:", errno)
32 return
33 }
34
35 fmt.Printf("Memory: total=%d MB free=%d MB buffer=%d MB\n",
36 info.Totalram*uint64(info.MemUnit)/1024/1024,
37 info.Freeram*uint64(info.MemUnit)/1024/1024,
38 info.Bufferram*uint64(info.MemUnit)/1024/1024)
39 fmt.Printf("Swap: total=%d MB free=%d MB\n",
40 info.Totalswap*uint64(info.MemUnit)/1024/1024,
41 info.Freeswap*uint64(info.MemUnit)/1024/1024)
42}
Hierdoor worden variabelen zonder labels gelezen. Hoewel anonieme waarden daadwerkelijk in een structuur zijn opgeslagen, zijn er geen labels of leesbare markeringen in de code.
Conclusie
- Het gebruik van Go's
syscallenunsafeis nog steeds veiliger dan C/CGo - Als je een groot project schrijft dat eenvoudig uitgebreid kan worden:
- Maak geen anonieme variabelen; geef elk lid een naam.
- Als je een project schrijft met beperkt gebruik:
- Je kunt anonieme variabelen gebruiken om ruimtes vast te houden die daadwerkelijk ongebruikt zijn.
- Go's
syscallis krachtig en modern om laag-niveau aanroepen af te handelen