A Go syscall ragyogó helyettesítője az alacsony szintű I/O-nak
Összegzés
Megismerkedünk a direkt System call-lal Go nyelven. Mivel a Go szigorú fordítói hibákat és merev GC-t kínál, sokkal jobb a low-level hívásokat Pure Go-ban helyettesíteni. Szerencsére a legtöbb C függvényhívás teljes mértékben újraimplementálásra került Go-ban, megfelelő és korszerű módon. Vessünk rá egy pillantást.
System call
A System call egy direkt kérés az operációs rendszer felé. Mivel a rendszer általában merev, régimódi stílusban íródik, mivel közvetlenül a hardware-en fut, figyelembe kell vennünk, hogy a hívásának szigorú és helyes kérést kell teljesítenie. Így, még ha nincs is szükségünk néhány változóra, akkor is ki kell töltenünk a méretet, függetlenül a felhasználástól. Nézzük meg egy teljesen működő példával.
Teljes példa
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}
Ez a példa tartalmazza az összes változót, és kiterjedt információkat nyomtat az aktuális rendszerinformációkról.
Összehasonlíthatjuk ezt a kódot egy szekrénnyel és egy kulccsal.
A syscall.SYS_SYSINFO egy kulcs, amely kinyit egy szekrényt, ami a kernelen belül található.
Ezért fontos a megfelelő kulcs használata a szekrényhez.
Mi történne, ha a syscall.SYS_GETPID-et használnánk ehhez a híváshoz?
Ez a kulcs egy szekrényhez, ami Process ID-t tartalmaz.
Ez megpróbálna PID-t szerezni a rendszerinformációk számára fenntartott helyről.
Ennek eredményeként az információk egyike sem olvasható be helyesen; a hívásnak hibás állapotúként kell visszatérnie.
Most tudnunk kell, hogy mely elemeket tartalmazza, és hogyan vannak sorrendben az elemek. A szekrény első nyílásában az Uptime található, 2^64 mérettel. Ha 2^32-vel próbáljuk beolvasni, a bit-sorozat nem kerül teljes mértékben beolvasásra. Nem használhatunk ilyen típusú részleges binárisokat, hacsak nem low-level trükköket fogunk írni.
64 bit bináris adat beolvasása után végre a második nyílásban vagyunk. Csak akkor olvasható be pontosan, ha beolvastuk az előző 64 bites méretű egészet.
Ezeknek a szigorú és logikus folyamatoknak a megismétlésével, hogy megfelelő információt szerezzünk a rendszerből, megfelelően kezelhetjük a beolvasott adatokat.
Hogyan hagyjuk ki a 'változóneveket'
Bár magukat a változókat nem tudjuk 'kihagyni', fontos megkülönböztetni a használt és az eldobott változókat. Ha a program felhasználása kellően egyértelmű, jobb névtelen változókat használni placeholder-ként, mint címkézni minden értéket, még akkor is, ha soha nem kerülnek felhasználásra. Nézzük meg ezt egy példával, a "Free Memory Checker"-rel.
Példa - Szabad memória ellenőrző (Free Memory Checker)
A Szabad memória/Swaps ellenőrzésekor nincs szükségünk más információra, amely eltérő erőforrásokat jelez. A jobb láthatóság érdekében anonim változókat hozhat létre a specifikus helyek tárolására.
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 // A névtelen és nem használtak _ jellel vannak megjelölve
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}
Következésképpen a változók címkék nélkül kerülnek beolvasásra. Bár az anonim értékek ténylegesen egy struktúrában vannak tárolva, nincsenek címkék/olvasható jelzések a kódon.
Konklúzió
- A Go
syscallésunsafehasználata még mindig biztonságosabb, mint a C/CGo - Ha egy hatalmas projektet ír, amelyet könnyen ki lehet terjeszteni:
- Ne hozzon létre anonim változókat; adjon nevet minden tagnak.
- Ha egy korlátozott felhasználású projektet ír:
- Használhat anonim változókat a ténylegesen nem használt helyek tárolására.
- A Go
syscallhatékony és modern a low-level hívások kezelésében