Go syscall stanowi znakomite zastąpienie niskopoziomowego I/O
Podsumowanie
Zapoznamy się z bezpośrednim wywołaniem systemowym w Go. Ponieważ Go oferuje ścisłe błędy kompilatora i sztywny GC, znacznie lepiej jest zastąpić wywołania niskopoziomowe w Pure Go. Na szczęście większość wywołań funkcji C jest w pełni zaimplementowana w Go, w dobry i współczesny sposób. Przyjrzyjmy się temu.
Wywołanie systemowe
Wywołanie systemowe to bezpośrednie żądanie do systemu operacyjnego. Ponieważ system jest zazwyczaj pisany w sztywnym, staroświeckim stylu, ponieważ działa bezpośrednio na sprzęcie, musimy wziąć pod uwagę, że jego wywołanie musi dostarczyć ścisłą i poprawną formę żądania. Zatem, nawet jeśli nie potrzebujemy niektórych zmiennych, nadal musimy wypełnić rozmiar niezależnie od użycia. 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 obszerne informacje o bieżącym stanie systemu.
Możemy porównać ten kod do szafki i klucza.syscall.SYS_SYSINFO to klucz, który otwiera szafkę znajdującą się w jądrze.
Dlatego ważne jest użycie prawidłowego klucza do szafki.
Co się stanie, gdy użyjemy syscall.SYS_GETPID dla tego wywołania?
Jest to klucz do szafki, która zawiera identyfikator procesu (Process ID).
Spowoduje to próbę pobrania PID z miejsca przeznaczonego na informacje systemowe.
W rezultacie żadne informacje nie mogą być prawidłowo odczytane; wywołanie musi zostać zwrócone jako stan niepowodzenia.
Teraz musimy wiedzieć, jakie elementy są zawarte i w jakiej kolejności. W pierwszym slocie szafki mamy Uptime, o rozmiarze 2^64. Jeśli spróbujemy odczytać to z 2^32, sekwencja bitów nie zostanie w pełni odczytana. Nie możemy używać tego rodzaju 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ć dokładnie tylko wtedy, gdy odczytaliśmy poprzednią liczbę całkowitą o rozmiarze 64 bitów.
Powtarzając te ścisłe i logiczne przepływy, aby uzyskać prawidłowe informacje z systemu, możemy prawidłowo przetwarzać odczytane dane.
Jak pominąć „nazwy zmiennych”
Chociaż nie możemy „pominąć” samych zmiennych, ważne jest, aby rozróżnić zmienne używane i te odrzucone. Jeśli użycie programu jest wystarczająco jasne, lepiej jest używać bezimiennych zmiennych jako symboli zastępczych, niż etykietować każdą wartość, nawet jeśli nie są one używane na zawsze. Sprawdźmy to na przykładzie „Free Memory Checker”.
Przykład – Free Memory Checker
Podczas sprawdzania wolnej pamięci/swapów nie potrzebujemy innych informacji wskazujących na różne zasoby. Aby osiągnąć lepszą widoczność, można utworzyć anonimowe zmienne, aby przechowywać określone miejsca.
1package main
2
3import (
4 "fmt"
5 "syscall"
6 "unsafe"
7)
8
9type sysinfo_t struct {
10 _ int64 // anonimowe i nieużywane zmienne są oznaczane jako _
11 _ [3]uint64
12 Totalram uint64
13 Freeram uint64
14 Sharedram uint64
15 Bufferram uint64
16 Totalswap uint64
17 Freeswap uint64
18 _ uint16
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ż anonimowe wartości są faktycznie przechowywane w strukturze, w kodzie nie ma etykiet/czytelnych oznaczeń.
Konkluzja
- Używanie
syscalliunsafew Go jest nadal bezpieczniejsze niż C/CGo. - Jeśli piszesz duży projekt, który można łatwo rozbudować:
- Nie twórz anonimowych zmiennych; nadawaj nazwy każdemu członkowi.
- Jeśli piszesz projekt o ograniczonym zastosowaniu:
- Możesz używać anonimowych zmiennych do przechowywania miejsc, które faktycznie nie są używane.
syscallw Go jest potężny i nowoczesny w obsłudze wywołań niskopoziomowych.