GoSudaLlamadas directas al sistema Linux en Go puro con syscall.Syscall y unsafe.Pointer
Resumen
Aprenderemos sobre las llamadas directas al sistema (system call) en Go. Dado que Go ofrece errores de compilación estrictos y un recolector de basura (GC) riguroso, es mucho mejor reemplazar las llamadas de bajo nivel por Go puro. Afortunadamente, la mayoría de las llamadas a funciones de C están completamente reimplementadas en Go, de una manera buena y contemporánea. Echemos un vistazo.
Llamada al sistema
Una llamada al sistema (system call) es una solicitud directa al sistema operativo. Dado que el sistema suele escribirse con un estilo rígido y anticuado, ya que se ejecuta directamente sobre el hardware, debemos tener en cuenta que su llamada debe entregar una forma de solicitud estricta y correcta. Por lo tanto, aunque no necesitemos algunas variables, aún debemos completar el tamaño independientemente de su uso. Veamos un ejemplo completamente funcional.
Ejemplo completo
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}
Este ejemplo incluye todas las variables e imprime información extensa sobre la información del sistema actual.
Podemos comparar este código con una cerradura y una llave.syscall.SYS_SYSINFO es una llave que abre una cerradura que se encuentra dentro del kernel.
Por lo tanto, es importante usar la llave correcta para la cerradura.
¿Qué ocurrirá si usamos syscall.SYS_GETPID para esta llamada?
Esta es una llave para una cerradura que contiene el ID de proceso.
Esto intentará obtener un PID desde un espacio destinado a la información del sistema.
Como resultado, no se puede leer correctamente ninguna de la información; la llamada debe devolver un estado de fallo.
Ahora, necesitamos saber qué elementos contiene y cómo están ordenados. En la primera ranura de la cerradura tenemos Uptime, con un tamaño de 2^64. Si intentamos leerlo con 2^32, la secuencia de bits no se lee completamente. No podemos utilizar este tipo de fragmentos binarios a menos que vayamos a escribir trucos de bajo nivel.
Tras leer 64 bits de datos binarios, finalmente llegamos a la segunda ranura. Solo puede leerse con precisión cuando hemos leído previamente el entero de 64 bits anterior.
Repitiendo estos flujos estrictos y lógicos para obtener información adecuada del sistema, podemos manejar correctamente los datos leídos.
Cómo omitir los 'nombres de variables'
Aunque no podemos 'omitir' las variables en sí, es importante distinguir entre las variables utilizadas y las descartadas. Si el uso del programa es suficientemente claro, es preferible usar variables sin nombre como marcadores de posición en lugar de etiquetar cada valor, aunque no se utilicen de forma permanente. Veamos esto con un ejemplo, "Verificador de memoria libre".
Ejemplo: Verificador de memoria libre
Al comprobar la memoria libre y el swap, no necesitamos otra información que indique recursos diferentes. Para lograr una mejor visibilidad, puede crear variables anónimas para contener espacios específicos.
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 _
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}
En consecuencia, las variables se leen sin etiquetas. Aunque los valores anónimos se almacenan realmente en una estructura, no hay etiquetas ni marcas legibles en el código.
Conclusión
- Usar
syscallyunsafede Go sigue siendo más seguro que C/CGo - Si está escribiendo un proyecto grande que puede expandirse fácilmente:
- No use variables anónimas; asigne nombres a cada uno de los miembros.
- Si está escribiendo un proyecto con un uso limitado:
- Puede usar variables anónimas para ocupar espacios que realmente no se utilizan.
- El
syscallde Go es potente y moderno para manejar llamadas de bajo nivel