GoSudaДиректни системни извиквания на Linux в чист Go с syscall.Syscall и unsafe.Pointer
Резюме
Ще научим за директните системни извиквания в Go. Тъй като Go предлага строги компилаторни грешки и стриктен GC, е много по-добре да заменяме low-level извикванията с чист Go. За щастие, повечето функции от C са напълно преизпълнени в Go, по добър и съвременен начин. Нека ги разгледаме.
Системно извикване
Системното извикване е директна заявка към операционната система. Тъй като системата обикновено е написана в строг, старомоден стил, тъй като работи directly върху хардуера, трябва да имаме предвид, че нейното извикване трябва да предаде строга и коректна форма на заявката. Така че, дори ако не се нуждаем от някои променливи, все пак трябва да попълним размера им независимо от използването. Нека проверим с напълно работещ пример.
Пълен пример
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}
Този пример включва всички променливи и извежда подробна информация за текущата системна информация.
Можем да сравним този код с ключалка и ключ.syscall.SYS_SYSINFO е ключ, който отключва ключалката, намираща се в ядрото.
Затова използването на правилния ключ за ключалката е важно.
Какво ще се случи, ако използваме syscall.SYS_GETPID за това извикване?
Това е ключ за ключалка, която съдържа идентификатор на процес (PID).
Това ще се опита да вземе PID от пространството за системна информация.
В резултат нито една от информациите не може да бъде прочетена коректно; извикването трябва да върне неуспешно състояние.
Сега трябва да знаем кои елементи се съдържат и как са подредени. В първия слот на ключалката имаме Uptime, с размер 2^64. Ако се опитаме да го прочетем с 2^32, битовата последователност не се прочита напълно. Не можем да използваме такива частични двоични данни, освен ако не пишем low-level трикове.
След четене на 64 бита двоични данни, най-накрая сме на втория слот. Той може да бъде прочетен точно само когато сме прочели предишното 64-битово цяло число.
Чрез повтаряне на тези строги и логически стъпки за получаване на правилна информация от системата, можем коректно да обработваме прочетените данни.
Как да пропуснем 'имената на променливите'
Въпреки че не можем да "пропуснем" самите променливи, е важно да разграничаваме използваните и отхвърлените променливи. Ако предназначението на програмата е достатъчно ясно, по-добре е да използваме безименни променливи като запазени места, вместо да етикетираме всяка стойност, дори ако те не се използват завинаги. Нека проверим това с пример, "Проверка на свободната памет".
Пример – Проверка на свободната памет
При проверка на свободната памет/swap, не се нуждаем от другата информация, която показва различни ресурси. За по-добра яснота можете да създадете анонимни променливи, които да съхраняват конкретните места.
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 // анонимни и неизползваните се маркират с _
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}
Следователно променливите се четат без етикети. Въпреки че анонимните стойности всъщност се съхраняват в структура, в кода няма етикети или ясно четливи маркировки.
Заключение
- Използването на
syscallиunsafeв Go все още е по-безопасно от C/CGo - Ако пишете голям проект, който лесно може да се разширява:
- Не използвайте анонимни променливи; дайте имена на всеки член.
- Ако пишете проект с ограничена употреба:
- Можете да използвате анонимни променливи, за да запазите места, които всъщност не се използват.
syscallв Go е мощен и модерен инструмент за работа с low-level извиквания