Extendiendo el Kernel con eBPF

Extended Berkeley Packet Filter (eBPF) es una máquina virtual en el kernel que ejecuta programas eBPF proporcionados por el usuario para ampliar la funcionalidad del kernel. Estos programas se pueden vincular a sondas o eventos en el kernel y se pueden usar para recopilar estadísticas, monitorear y depurar útiles del kernel. Un programa se carga en el kernel utilizando la llamada al bpf(2) y el usuario lo proporciona como un blob binario de instrucciones de máquina eBPF. El sistema de compilación de Android es compatible con la compilación de programas C en eBPF utilizando la sintaxis de archivo de compilación simple que se describe en este documento.

Puede encontrar más información sobre los componentes internos y la arquitectura de eBPF en la página eBPF de Brendan Gregg .

Android incluye un cargador y una biblioteca eBPF que cargan programas eBPF en el momento del arranque.

Cargador BPF de Android

Durante el arranque de Android, se cargan todos los programas eBPF ubicados en /system/etc/bpf/ . Estos programas son objetos binarios creados por el sistema de compilación de Android a partir de programas C y van acompañados de archivos Android.bp en el árbol fuente de Android. El sistema de compilación almacena los objetos generados en /system/etc/bpf y esos objetos pasan a formar parte de la imagen del sistema.

Formato de un programa Android eBPF C

Un programa eBPF C 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 will also define 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

Dónde:

• name_of_my_map es el nombre de su variable de mapa. Este nombre informa al cargador BPF del tipo de mapa a crear y con qué parámetros. Esta definición de estructura la proporciona el encabezado bpf_helpers.h incluido.

• PROGTYPE/PROGNAME representa el tipo del programa y el nombre del programa. El tipo de programa puede ser cualquiera de los enumerados en la siguiente tabla. Cuando un tipo de programa no aparece en la lista, no existe una convención de nomenclatura estricta para el programa; el nombre solo necesita ser conocido por el proceso que adjunta el programa.

• PROGFUNC es una función que, cuando se compila, se coloca en una sección del archivo resultante.

Se pueden 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, consulte 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 el programa utiliza las funciones auxiliares de BPF proporcionadas por el kernel. Especifique el nombre de la licencia de su 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 genere un programa eBPF .c , debe crear una entrada en el archivo Android.bp del proyecto. Por ejemplo, para construir un programa eBPF C llamado bpf_test.c , haga la siguiente entrada en el archivo Android.bp de su proyecto:

bpf {
    name: "bpf_test.o",
    srcs: ["bpf_test.c"],
    cflags: [
        "-Wall",
        "-Werror",
    ],
}

Esta entrada compila el programa C que da como resultado el objeto /system/etc/bpf/bpf_test.o . Al arrancar, el sistema Android carga automáticamente el programa bpf_test.o en el núcleo.

Archivos disponibles en sysfs

Durante el arranque, el sistema Android carga automáticamente todos los objetos eBPF desde /system/etc/bpf/ , crea los mapas que necesita el programa y ancla el programa cargado con sus mapas al sistema de archivos BPF. Estos archivos se pueden usar para una mayor interacción con el programa eBPF o para leer mapas. Esta sección describe las convenciones utilizadas para nombrar estos archivos y sus ubicaciones en sysfs.

Se crean y anclan los siguientes archivos:

• Para cualquier programa cargado, asumiendo que PROGNAME es el nombre del programa y FILENAME es el nombre del archivo eBPF C, el cargador de Android crea y fija cada programa en /sys/fs/bpf/prog_FILENAME_PROGTYPE_PROGNAME .

  Por ejemplo, para el ejemplo anterior de punto de sched_switch en myschedtp.c , se crea un archivo de programa y se ancla a /sys/fs/bpf/prog_myschedtp_tracepoint_sched_sched_switch .

• Para cualquier mapa creado, asumiendo que MAPNAME es el nombre del mapa y FILENAME es el nombre del archivo eBPF C, el cargador de Android crea y ancla cada mapa a /sys/fs/bpf/map_FILENAME_MAPNAME .

  Por ejemplo, para el ejemplo anterior de punto de sched_switch en myschedtp.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 BPF de Android devuelve un descriptor de archivo del archivo /sys/fs/bpf . Este descriptor de archivo se puede utilizar para otras operaciones, como leer mapas o adjuntar un programa a un punto de seguimiento.

Biblioteca BPF de Android

La biblioteca BPF de Android se llama libbpf_android.so y es parte de la imagen del sistema. Esta biblioteca proporciona al usuario la funcionalidad eBPF de bajo nivel necesaria para crear y leer mapas, crear sondas, puntos de seguimiento y búferes de rendimiento.

Adjuntar programas a puntos de rastreo

Los programas de Tracepoint se cargan automáticamente al arrancar. Después de la carga, el programa de punto de rastreo debe activarse siguiendo estos pasos:

1. Llame a bpf_obj_get() para obtener el programa fd desde la ubicación del archivo anclado. Para obtener más información, consulte Archivos disponibles en sysfs .
2. Llame bpf_attach_tracepoint() en la biblioteca BPF, pasándole el programa fd y el nombre del punto de seguimiento.

El siguiente ejemplo de código muestra cómo adjuntar el punto de sched_switch definido en el archivo de origen myschedtp.c anterior (no se muestra la comprobació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));

Lectura de los mapas

Los mapas BPF admiten estructuras o tipos arbitrarios de claves y valores complejos. La biblioteca BPF de Android incluye una clase android::BpfMap que utiliza plantillas de C++ para crear instancias de BpfMap en función del tipo de clave y valor del mapa en cuestión. El ejemplo de código anterior demuestra el uso de un BpfMap con clave y valor como números enteros. Los enteros también pueden ser estructuras arbitrarias.

Por lo tanto, la clase BpfMap en plantilla facilita la definición de un objeto BpfMap personalizado adecuado para el mapa en particular. Luego, se puede acceder al mapa utilizando las funciones generadas a medida, que reconocen el tipo, lo que da como resultado un código más limpio.

Para obtener más información acerca de BpfMap , consulte las fuentes de Android .

Problemas de depuración

Durante el tiempo de arranque, 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. Filtrar los registros logcat por "bpf" imprime todos los mensajes y cualquier error detallado durante el tiempo de carga, como los errores del verificador eBPF.

Ejemplos de eBPF en Android

Los siguientes programas en AOSP proporcionan ejemplos adicionales del uso de eBPF:

• El programa netd eBPF C es utilizado por el demonio de red (netd) en Android para diversos fines, como el filtrado de sockets y la recopilación de estadísticas. Para ver cómo se usa este programa, consulte las fuentes del monitor de tráfico eBPF .

• El programa time_in_state eBPF C calcula la cantidad de tiempo que una aplicación de Android pasa en diferentes frecuencias de CPU, que se utiliza para calcular la potencia.

• En Android 12, el programa gpu_mem eBPF C rastrea el uso total de la memoria GPU para cada proceso y para todo el sistema. Este programa se utiliza para la creación de perfiles de memoria GPU.