El filtro de paquetes extendido de Berkeley (eBPF) es una máquina virtual en el kernel que ejecuta programas eBPF proporcionados por el usuario para extender la funcionalidad del kernel. Estos programas se pueden conectar a sondas o eventos en el kernel y se pueden usar para recopilar estadísticas útiles del kernel, supervisarlo y depurarlo. Se carga un programa en el kernel mediante la llamada de sistema bpf(2) y el usuario lo proporciona como un BLOB binario de instrucciones de la máquina de eBPF. El sistema de compilación de Android admite la compilación de programas C en eBPF con la sintaxis simple de archivos de compilación que se describe en este documento.
Puedes encontrar más información sobre los componentes internos y la arquitectura de eBPF en la página de eBPF de Brenda Gregg.
Android incluye un cargador de eBPF y una biblioteca que carga programas de eBPF en el momento del inicio.
Cargador de BPF de Android
Durante el inicio de Android, se cargan todos los programas de eBPF ubicados en /system/etc/bpf/. Estos programas son objetos binarios que compila el sistema de compilación de Android a partir de programas C y se acompañan de archivos Android.bp en el árbol de origen de Android. El sistema de compilación almacena los objetos generados en /system/etc/bpf, y esos objetos se convierten en parte de la imagen del sistema.
Formato de un programa C de eBPF de Android
Un programa C de eBPF debe tener el siguiente formato:
#include <bpf_helpers.h>
/* Define one or more maps in the maps section, for example
* define a map of type array int -> uint32_t, with 10 entries
*/
DEFINE_BPF_MAP(name_of_my_map, ARRAY, int, uint32_t, 10);
/* this also defines type-safe accessors:
* value * bpf_name_of_my_map_lookup_elem(&key);
* int bpf_name_of_my_map_update_elem(&key, &value, flags);
* int bpf_name_of_my_map_delete_elem(&key);
* as such it is heavily suggested to use lowercase *_map names.
* Also note that due to compiler deficiencies you cannot use a type
* of 'struct foo' but must instead use just 'foo'. As such structs
* must not be defined as 'struct foo {}' and must instead be
* 'typedef struct {} foo'.
*/
DEFINE_BPF_PROG("PROGTYPE/PROGNAME", AID_*, AID_*, PROGFUNC)(..args..) {
<body-of-code
... read or write to MY_MAPNAME
... do other things
>
}
LICENSE("GPL"); // or other license
donde:
name_of_my_mapes el nombre de tu variable de mapa. Este nombre informa al cargador de BPF el tipo de mapa que se creará y con qué parámetros. El encabezadobpf_helpers.hincluido proporciona esta definición de struct.PROGTYPE/PROGNAMErepresenta el tipo y el nombre del programa. El tipo de programa puede ser cualquiera de los que se indican en la siguiente tabla. Cuando no se incluye un tipo de programa, no hay una convención de nombres estricta para el programa. El proceso que lo adjunta solo debe conocer el nombre.PROGFUNCes una función que, cuando se compila, se coloca en una sección del archivo resultante.
| kprobe | Conecta PROGFUNC a una instrucción del kernel con la infraestructura de kprobe. PROGNAME debe ser el nombre de la función del kernel que se está kprobando. Consulta la documentación del kernel de kprobe para obtener más información sobre los kprobes.
|
|---|---|
| punto de seguimiento | Conecta PROGFUNC a un punto de seguimiento. PROGNAME debe tener el formato SUBSYSTEM/EVENT. Por ejemplo, una sección de punto de seguimiento para adjuntar funciones a los eventos de cambio de contexto del programador sería SEC("tracepoint/sched/sched_switch"), en la que sched es el nombre del subsistema de seguimiento y sched_switch es el nombre del evento de seguimiento. Consulta la documentación del kernel de eventos de seguimiento para obtener más información sobre los puntos de seguimiento.
|
| filtro sk | El programa funciona como un filtro de socket de red. |
| programa | El programa funciona como un clasificador de tráfico de red. |
| cgroupskb, cgroupsock | El programa se ejecuta cada vez que los procesos de un CGroup crean un socket AF_INET o AF_INET6. |
Puedes encontrar tipos adicionales en el código fuente del cargador.
Por ejemplo, el siguiente programa myschedtp.c agrega información sobre el PID de tarea más reciente que se ejecutó en una CPU en particular. Este programa logra su objetivo creando un mapa y definiendo una función tp_sched_switch que se puede adjuntar al evento de seguimiento sched:sched_switch. Para obtener más información, consulta Cómo adjuntar programas a puntos de seguimiento.
#include <linux/bpf.h>
#include <stdbool.h>
#include <stdint.h>
#include <bpf_helpers.h>
DEFINE_BPF_MAP(cpu_pid_map, ARRAY, int, uint32_t, 1024);
struct switch_args {
unsigned long long ignore;
char prev_comm[16];
int prev_pid;
int prev_prio;
long long prev_state;
char next_comm[16];
int next_pid;
int next_prio;
};
DEFINE_BPF_PROG("tracepoint/sched/sched_switch", AID_ROOT, AID_SYSTEM, tp_sched_switch)
(struct switch_args *args) {
int key;
uint32_t val;
key = bpf_get_smp_processor_id();
val = args->next_pid;
bpf_cpu_pid_map_update_elem(&key, &val, BPF_ANY);
return 1; // return 1 to avoid blocking simpleperf from receiving events
}
LICENSE("GPL");
La macro LICENSE se usa para verificar si el programa es compatible con la licencia del kernel cuando usa las funciones auxiliares de BPF que proporciona el kernel. Especifica el nombre de la licencia de tu programa en forma de cadena, como LICENSE("GPL") o LICENSE("Apache 2.0").
Formato del archivo Android.bp
Para que el sistema de compilación de Android compile un programa .c de eBPF, debes crear una entrada en el archivo Android.bp del proyecto. Por ejemplo, para compilar un programa C de eBPF llamado bpf_test.c, realiza la siguiente entrada en el archivo Android.bp de tu proyecto:
bpf {
name: "bpf_test.o",
srcs: ["bpf_test.c"],
cflags: [
"-Wall",
"-Werror",
],
}
Esta entrada compila el programa C, lo que genera el objeto /system/etc/bpf/bpf_test.o. Durante el inicio, el sistema Android carga automáticamente el programa bpf_test.o en el kernel.
Archivos disponibles en sysfs
Durante el inicio, el sistema Android carga automáticamente todos los objetos eBPF de /system/etc/bpf/, crea los mapas que necesita el programa y fija el programa cargado con sus mapas en el sistema de archivos BPF. Luego, estos archivos se pueden usar para interactuar más con el programa eBPF o leer mapas. En esta sección, se describen las convenciones que se usan para nombrar estos archivos y sus ubicaciones en sysfs.
Se crean y fijan los siguientes archivos:
Para cualquier programa cargado, suponiendo que
PROGNAMEes el nombre del programa yFILENAMEes el nombre del archivo C de eBPF, el cargador de Android crea y fija cada programa en/sys/fs/bpf/prog_FILENAME_PROGTYPE_PROGNAME.Por ejemplo, para el ejemplo de punto de seguimiento
sched_switchanterior enmyschedtp.c, se crea un archivo de programa y se fija a/sys/fs/bpf/prog_myschedtp_tracepoint_sched_sched_switch.Para cualquier mapa creado, suponiendo que
MAPNAMEes el nombre del mapa yFILENAMEes el nombre del archivo C de eBPF, el cargador de Android crea y fija cada mapa a/sys/fs/bpf/map_FILENAME_MAPNAME.Por ejemplo, en el ejemplo anterior de punto de seguimiento
sched_switchenmyschedtp.c, se crea un archivo de mapa y se fija a/sys/fs/bpf/map_myschedtp_cpu_pid_map.bpf_obj_get()en la biblioteca de BPF de Android muestra un descriptor de archivo del archivo/sys/fs/bpffijado. Este descriptor de archivo se puede usar para otras operaciones, como leer mapas o adjuntar un programa a un punto de seguimiento.
Biblioteca de BPF de Android
La biblioteca de BPF de Android se llama libbpf_android.so y forma parte de la imagen del sistema. Esta biblioteca le proporciona al usuario las capacidades de eBPF de bajo nivel necesarias para crear y leer mapas, crear sondas, puntos de seguimiento y búferes de rendimiento.
Cómo adjuntar programas a puntos de seguimiento
Los programas de punto de seguimiento se cargan automáticamente durante el inicio. Después de la carga, el programa de punto de seguimiento se debe activar con estos pasos:
- Llama a
bpf_obj_get()para obtener el programafdde la ubicación del archivo fijado. Para obtener más información, consulta Archivos disponibles en sysfs. - Llama a
bpf_attach_tracepoint()en la biblioteca de BPF y pásale el programafdy el nombre del punto de seguimiento.
En la siguiente muestra de código, se indica cómo adjuntar el punto de seguimiento sched_switch definido en el archivo fuente myschedtp.c anterior (no se muestra la verificación de errores):
char *tp_prog_path = "/sys/fs/bpf/prog_myschedtp_tracepoint_sched_sched_switch";
char *tp_map_path = "/sys/fs/bpf/map_myschedtp_cpu_pid";
// Attach tracepoint and wait for 4 seconds
int mProgFd = bpf_obj_get(tp_prog_path);
int mMapFd = bpf_obj_get(tp_map_path);
int ret = bpf_attach_tracepoint(mProgFd, "sched", "sched_switch");
sleep(4);
// Read the map to find the last PID that ran on CPU 0
android::bpf::BpfMap<int, int> myMap(mMapFd);
printf("last PID running on CPU %d is %d\n", 0, myMap.readValue(0));
Cómo leer los mapas
Los mapas de BPF admiten estructuras o tipos de claves y valores complejos arbitrarios. La biblioteca de BPF de Android incluye una clase android::BpfMap que utiliza plantillas de C++ para crear instancias de BpfMap según el tipo de clave y valor del mapa en cuestión. En la muestra de código anterior, se muestra el uso de un BpfMap con clave y valor como números enteros. Los números enteros también pueden ser estructuras arbitrarias.
Por lo tanto, la clase BpfMap con plantillas te permite definir un objeto BpfMap personalizado adecuado para el mapa en particular. Se puede acceder al mapa con las funciones generadas de manera personalizada, que reconocen tipos, lo que da como resultado un código más limpio.
Para obtener más información sobre BpfMap, consulta las fuentes de Android.
Cómo depurar problemas
Durante el tiempo de inicio, se registran varios mensajes relacionados con la carga de BPF. Si el proceso de carga falla por algún motivo, se proporciona un mensaje de registro detallado en logcat. Si filtras los registros de logcat por bpf, se imprimen todos los mensajes y cualquier error detallado durante el tiempo de carga, como los errores del verificador de eBPF.
Ejemplos de eBPF en Android
Los siguientes programas en AOSP proporcionan ejemplos adicionales del uso de eBPF:
El daemon de red (netd) en Android usa el programa C de eBPF
netdpara varios fines, como el filtrado de sockets y la recopilación de estadísticas. Para ver cómo se usa este programa, consulta las fuentes del monitor de tráfico de eBPF.El programa C de eBPF
time_in_statecalcula la cantidad de tiempo que una app para Android pasa en diferentes frecuencias de la CPU, que se usa para calcular la energía.En Android 12, el programa
gpu_memde eBPF C hace un seguimiento del uso total de memoria de GPU para cada proceso y para todo el sistema. Este programa se usa para generar perfiles de memoria de GPU.