Go syscall predstavuje vynikajúcu náhradu nízkoúrovňového I/O.
Zhrnutie
Budeme sa zaoberať priamym systémovým volaním v Go. Keďže Go ponúka prísne chyby kompilátora a rigidný GC, je oveľa lepšie nahradiť nízkoúrovňové volania v čistom Go. Našťastie, väčšina volaní C funkcií je plne reimplementovaná v Go, a to dobrým a moderným spôsobom. Pozrime sa na to.
Systémové volanie
Systémové volanie je priama požiadavka na operačný systém. Keďže systém je zvyčajne napísaný rigidným, staromódnym štýlom, pretože beží priamo na hardvéri, musíme zvážiť, že jeho volanie musí poskytovať prísnu a správnu formu požiadavky. Takže, aj keď nepotrebujeme niektoré premenné, stále musíme vyplniť veľkosť bez ohľadu na použitie. Pozrime sa na to s plne funkčným príkladom.
Kompletný príklad
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}
Tento príklad zahŕňa všetky premenné a vypisuje rozsiahle informácie o aktuálnom systéme.
Tento kód môžeme prirovnať k skrinke a kľúču.syscall.SYS_SYSINFO je kľúč, ktorý odomyká skrinku nachádzajúcu sa vo vnútri jadra.
Preto je dôležité použiť správny kľúč pre skrinku.
Čo sa stane, ak pre toto volanie použijeme syscall.SYS_GETPID?
Toto je kľúč k skrinke, ktorá obsahuje ID procesu.
Toto sa pokúsi získať PID z priestoru pre systémové informácie.
V dôsledku toho sa žiadna z informácií nedá správne prečítať; volanie musí byť vrátené ako neúspešný stav.
Teraz potrebujeme vedieť, ktoré položky sú obsiahnuté a ako sú položky usporiadané. V prvom slote skrinky máme Uptime s veľkosťou 2^64. Ak sa to pokúsime prečítať s 2^32, bitová sekvencia sa neprečíta úplne. Nemôžeme používať tieto druhy čiastočných binárnych súborov, pokiaľ nebudeme písať nízkoúrovňové triky.
Po prečítaní 64 bitov binárnych dát sme konečne na druhom slote. Dá sa prečítať presne iba vtedy, ak sme prečítali predchádzajúce 64-bitové celé číslo.
Opakovaním týchto prísnych a logických postupov na získanie správnych informácií zo systému môžeme správne spracovať prečítané dáta.
Ako preskočiť „názvy premenných“
Aj keď nemôžeme „preskočiť“ samotné premenné, je dôležité rozlišovať použité premenné a tie, ktoré boli zahodené. Ak je použitie programu dostatočne jasné, je lepšie použiť bezmenné premenné ako zástupné symboly, než označovať každú hodnotu, aj keď sa nikdy nepoužije. Pozrime sa na to na príklade „Kontrola voľnej pamäte“.
Príklad – Kontrola voľnej pamäte
Pri kontrole voľnej pamäte/swapov nepotrebujeme iné informácie, ktoré naznačujú rôzne zdroje. Pre dosiahnutie lepšej prehľadnosti môžete vytvoriť anonymné premenné na uchovanie špecifických priestorov.
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 _ // Anonymné a nepoužité sú označené ako _
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}
Následne sa premenné čítajú bez štítkov. Hoci anonymné hodnoty sú skutočne uložené do štruktúry, v kóde nie sú žiadne štítky/čitateľné značky.
Záver
- Používanie
syscallaunsafev Go je stále bezpečnejšie ako C/CGo - Ak píšete obrovský projekt, ktorý sa dá ľahko rozšíriť:
- Nevytvárajte anonymné premenné; vytvorte pre každý člen názvy.
- Ak píšete projekt, ktorý má obmedzené použitie:
- Môžete použiť anonymné premenné na uchovanie priestorov, ktoré sú skutočne nepoužité.
syscallv Go je výkonný a moderný na manipuláciu s nízkoúrovňovými volaniami