GoSudaBezpośrednie wywołania systemowe Linuksa w czystym Go z użyciem syscall.Syscall i unsafe.Pointer
Podsumowanie
Dowiemy się o bezpośrednich wywołaniach systemowych w Go. Ponieważ Go oferuje rygorystyczne błędy kompilatora oraz sztywny GC, znacznie lepiej jest zastępować niskopoziomowe wywołania czystym Go. Na szczęście większość wywołań funkcji C została w pełni zreimplementowana w Go, w dobry i nowoczesny sposób. Przyjrzyjmy się temu.
Wywołanie systemowe
Wywołanie systemowe to bezpośrednie żądanie kierowane do systemu operacyjnego. Ponieważ system jest zazwyczaj napisany w sztywnym, staromodnym stylu, gdyż działa bezpośrednio na sprzęcie, musimy uwzględnić, że jego wywołanie musi dostarczyć ścisłą i poprawną formę żądania. Zatem nawet jeśli nie potrzebujemy pewnych zmiennych, nadal musimy wypełnić ich rozmiar, niezależnie od tego, czy są używane. Sprawdźmy to na w pełni działającym przykładzie.
Pełny przykład
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}
Ten przykład zawiera wszystkie zmienne i wyświetla szczegółowe informacje o bieżącym stanie systemu.
Możemy porównać ten kod do zamka i klucza.syscall.SYS_SYSINFO jest kluczem, który otwiera zamek znajdujący się wewnątrz jądra.
Dlatego użycie właściwego klucza do zamka jest istotne.
Co się stanie, gdy użyjemy syscall.SYS_GETPID dla tego wywołania?
Jest to klucz do zamka zawierającego identyfikator procesu (PID).
Spowoduje to próbę odczytu PID z obszaru informacji systemowych.
W rezultacie żadnych informacji nie da się poprawnie odczytać, a wywołanie zakończy się stanem błędu.
Teraz musimy wiedzieć, jakie elementy są zawarte i w jakiej kolejności są uporządkowane. W pierwszym slocie zamka znajduje się Uptime, o rozmiarze 2^64. Jeśli spróbujemy odczytać go za pomocą 2^32, sekwencja bitów nie zostanie odczytana w całości. Nie możemy używać takich częściowych danych binarnych, chyba że zamierzamy pisać niskopoziomowe sztuczki.
Po odczytaniu 64 bitów danych binarnych w końcu znajdujemy się w drugim slocie. Można go odczytać poprawnie dopiero wtedy, gdy wcześniej odczytaliśmy poprzednią 64-bitową liczbę całkowitą.
Powtarzając te rygorystyczne i logiczne przepływy, możemy uzyskać właściwe informacje z systemu i poprawnie obsłużyć odczytane dane.
Jak pominąć 'nazwy zmiennych'
Chociaż nie możemy faktycznie „pominąć” samych zmiennych, ważne jest, aby rozróżniać zmienne używane od odrzuconych. Jeśli przeznaczenie programu jest wystarczająco jasne, lepiej jest używać zmiennych bezimiennych jako symboli zastępczych, niż oznaczać każdą wartość etykietą, nawet jeśli nie są one używane na stałe. Sprawdźmy to na przykładzie „Free Memory Checker”.
Przykład - Free Memory Checker
Podczas sprawdzania wolnej pamięci i wymiany nie potrzebujemy innych informacji wskazujących na inne zasoby. Aby uzyskać lepszą czytelność, można utworzyć anonimowe zmienne, które zajmą określone miejsca.
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 // anonimowe, a nieużywane oznaczone jako _
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}
W konsekwencji zmienne są odczytywane bez etykiet. Chociaż wartości anonimowe faktycznie są przechowywane w strukturze, w kodzie nie ma etykiet ani czytelnych oznaczeń.
Podsumowanie końcowe
- Używanie
syscalliunsafew Go jest nadal bezpieczniejsze niż C/CGo - Jeśli piszesz duży projekt, który może być łatwo rozbudowywany:
- Nie twórz zmiennych anonimowych; nadaj każdemu członkowi nazwę.
- Jeśli piszesz projekt o ograniczonym zastosowaniu:
- Możesz używać zmiennych anonimowych do zajmowania miejsc, które faktycznie nie są używane.
syscallw Go jest potężny i nowoczesny w obsłudze niskopoziomowych wywołań