GoSudaDirekta systemanrop i Linux i ren Go med syscall.Syscall och unsafe.Pointer
Sammanfattning
Vi kommer att lära oss om direkta systemanrop i Go. Eftersom Go erbjuder strikta kompilatorfel och en stram skräpsamlare (GC) är det mycket bättre att ersätta lågnivåanrop med ren Go. Lyckligtvis är de flesta av C-funktionsanropen fullständigt omimplementerade i Go, på ett bra och modernt sätt. Låt oss titta på det.
Systemanrop
Ett systemanrop är en direkt begäran till operativsystemet. Eftersom systemet vanligtvis är skrivet i en strikt, föråldrad stil eftersom det körs direkt på hårdvaran, måste vi beakta att dess anrop måste leverera en strikt och korrekt form av begäran. Så, även om vi inte behöver vissa variabler, måste vi ändå ange storleken oavsett användning. Låt oss kontrollera detta med ett fullt fungerande exempel.
Fullständigt exempel
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}
Detta exempel innehåller alla variabler och skriver ut omfattande information om aktuell systeminformation.
Vi kan jämföra denna kod med ett lås och en nyckel.syscall.SYS_SYSINFO är en nyckel som låser upp ett lås som finns inuti en kärna.
Därför är det viktigt att använda rätt nyckel för låset.
Vad händer när vi använder syscall.SYS_GETPID för detta anrop?
Detta är en nyckel till ett lås som innehåller process-ID:t.
Detta kommer att försöka hämta ett PID från ett utrymme för systeminformation.
Som ett resultat kan ingen av informationen läsas korrekt; anropet måste returnera ett misslyckat tillstånd.
Nu behöver vi veta vilka objekt som finns och hur objekten är ordnade. I den första facket i låset finns Uptime, med en storlek på 2^64. Om vi försöker läsa detta med 2^32 läses bitsekvensen inte fullständigt. Vi kan inte använda sådana partiella binärer om vi inte ska skriva lågnivåtrick.
Efter att ha läst 64 bitar av binärdata befinner vi oss slutligen på ett andra fack. Det kan endast läsas korrekt när vi har läst föregående 64-bitars heltal.
Genom att upprepa dessa strikta och logiska flöden för att få korrekt information från ett system kan vi hantera den lästa datan på rätt sätt.
Hur man hoppar över 'variabelnamn'
Även om vi inte kan 'hoppa över' variabler själva är det viktigt att skilja mellan använda och kasserade variabler. Om programmets användning är tillräckligt tydlig är det bättre att använda namnlösa variabler som platshållare än att märka varje värde, även om de inte används för alltid. Låt oss kontrollera detta med ett exempel, "Free Memory Checker".
Exempel: Free Memory Checker
När vi kontrollerar ledigt minne/swap behöver vi inte annan information som indikerar andra resurser. För att uppnå bättre överskådlighet kan du skapa anonyma variabler för att hålla specifika utrymmen.
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 // anonymous, and unused ones are marked as _
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}
Följaktligen läses variablerna utan etiketter. Även om anonyma värden faktiskt lagras i en struktur finns det inga etiketter eller läsbara markeringar i koden.
Slutsats
- Att använda Gos
syscallochunsafeär fortfarande säkrare än C/CGo - Om du skriver ett stort projekt som lätt kan utökas:
- Skapa inte anonyma variabler; ge varje medlem ett namn.
- Om du skriver ett projekt med begränsad användning:
- Du kan använda anonyma variabler för att hålla utrymmen som faktiskt är oanvända.
- Gos
syscallär kraftfullt och modernt för att hantera lågnivåanrop