A partir del 27 de marzo de 2025, te recomendamos que uses android-latest-release en lugar de aosp-main para compilar y contribuir a AOSP. Para obtener más información, consulta Cambios en AOSP.
Organiza tus páginas con colecciones
Guarda y categoriza el contenido según tus preferencias.
Los dispositivos que se lanzan con Android 12 y usan versiones de kernel superiores a la v5.4 deben enviarse con el kernel de GKI. Para que los socios puedan acceder a DebugFS en compilaciones de userdebug mientras desarrollan en el kernel de GKI, la configuración del kernel CONFIG_DEBUG_FS está habilitada en la defconfig de GKI.
Nunca actives DebugFS en compilaciones de usuario para dispositivos que se inicien en Android 12.
Las compilaciones de userdebug tienen una mejor cobertura de pruebas que las compilaciones de usuario y se prueban mucho durante el ciclo de desarrollo. El siguiente plan minimiza la diferencia entre los dos tipos de compilación con respecto al acceso a DebugFS y proporciona los siguientes beneficios:
Evita que las compilaciones de userdebug dependan accidentalmente de DebugFS para obtener funciones nuevas.
Garantiza que cualquier funcionalidad existente que se vea afectada por la falta de DebugFS se conozca al principio del ciclo de desarrollo.
Los accesos a DebugFS en compilaciones de userdebug se clasifican de la siguiente manera:
Inicializaciones de archivos DebugFS durante el inicio del dispositivo, como un acceso de escritura a un archivo en DebugFS para activar la recopilación de datos de depuración
Generación de informes de errores: El HAL de dumpstate lee archivos DebugFS cuando dumpstate invoca a DumpstateBoard(). Esta información forma parte del informe de errores.
Pruebas y validación específicas del dispositivo
En la siguiente tabla, se describe cómo se admite cada una de estas tres categorías en Android 12. Ten en cuenta que lo siguiente solo se aplica a las compilaciones de userdebug, ya que DebugFS no se puede activar en las compilaciones de usuario.
Caso de uso
Compilación de userdebug de Android 12
Inicialización única de archivos DebugFS durante el inicio.
Este acceso ocurre solo una vez durante el tiempo de inicio.
El HAL de Dumpstate realiza esta acción durante la inicialización del HAL. Para habilitar lo mismo,
init activa DebugFS en compilaciones de userdebug antes de que se inicialice el HAL.
Init llama a umount() en DebugFS cuando el dispositivo completó el inicio.
Generación de informes de errores: El HAL de dumpstate lee archivos DebugFS, que se convierten en parte del informe de errores.
Se realiza mediante el HAL de dumpstate dentro de DumpstateBoard() cuando lo invoca dumpstate (DumpstateDevice.cpp).
La herramienta dumpstate (parte del framework de Android) garantiza que DebugFS se monte durante la invocación.
Pruebas y validación específicas del dispositivo
Root y shell de adb Activa DebugFS desde el shell de adb con acceso raíz1.
1Para activar DebugFS desde adb shell con acceso raíz, usa este comando:
adb shell mount -t debugfs debugfs /sys/kernel/debug.
Acciones obligatorias de los socios
Los socios deben implementar lo siguiente en función de estos cambios en los dispositivos Android 12:
No permitas el acceso de DebugFS durante el tiempo de ejecución. Se aplican las siguientes excepciones:
Generación de informes de errores (proviene del HAL de dumpstate)
Pruebas y validación (a las que se puede acceder con adb root y shell; asegúrate de que DebugFS se monte primero)
Los desarrolladores pueden configurar la propiedad persistente de depuración persist.dbg.keep_debugfs_mounted para mantener DebugFs montada en los reinicios en compilaciones de userdebug y eng.
Las pruebas de cumplimiento de GTS garantizan que el sistema de archivos DebugFS no se monte en compilaciones de usuarios. Las sentencias neverallow de Sepolicy garantizan que, en los dispositivos que se inician en Android 12 o versiones posteriores, no se les proporcione acceso a DebugFs a los procesos no autorizados.
El contenido y las muestras de código que aparecen en esta página están sujetas a las licencias que se describen en la Licencia de Contenido. Java y OpenJDK son marcas registradas de Oracle o sus afiliados.
Última actualización: 2025-07-27 (UTC)
[[["Fácil de comprender","easyToUnderstand","thumb-up"],["Resolvió mi problema","solvedMyProblem","thumb-up"],["Otro","otherUp","thumb-up"]],[["Falta la información que necesito","missingTheInformationINeed","thumb-down"],["Muy complicado o demasiados pasos","tooComplicatedTooManySteps","thumb-down"],["Desactualizado","outOfDate","thumb-down"],["Problema de traducción","translationIssue","thumb-down"],["Problema con las muestras o los códigos","samplesCodeIssue","thumb-down"],["Otro","otherDown","thumb-down"]],["Última actualización: 2025-07-27 (UTC)"],[],[],null,["# Use DebugFS in Android 12\n\nDevices that launch with Android 12 using kernel\nversions higher than v5.4 are required to ship with the GKI kernel. So that\npartners can access `DebugFS` in userdebug builds while they develop on the GKI\nkernel, the kernel config `CONFIG_DEBUG_FS` is enabled in the GKI defconfig.\n**Never mount `DebugFS` in user builds** for devices\nlaunching on Android 12.\n\n\nUserdebug builds have better test coverage than user builds and get heavily\ntested throughout the development cycle. The following plan minimizes the\ndifference between the two build types with respect to `DebugFS` access, and\nprovides these benefits:\n\n- Prevents userdebug builds from accidentally depending on `DebugFS` for new functionality\n- Ensures that any existing functionality that's broken by the lack of DebugFS is known early in the development cycle\n\n\nDebugfs accesses **in userdebug builds** are categorized as\nfollows:\n\n1. `DebugFS` file initializations during device boot, such as a write access to a file in `DebugFS` to turn on debug data collection.\n2. Bugreport generation: The dumpstate HAL reads `DebugFS` files when `DumpstateBoard()` is invoked by `dumpstate`. This information becomes part of the bug report.\n3. Device-specific testing and validation.\n\nThe following table describes how each of these three categories is\nsupported in Android 12. Note that the\nfollowing only applies to userdebug builds since `DebugFS` can't be\nmounted in user builds.\n\n| Use case | Android 12 userdebug build |\n|-------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| **One-time `DebugFS` files initialization, during startup** . This access **happens only once** during boot time. | Dumpstate HAL performs this during HAL initialization. To enable the same, init mounts `DebugFS` in userdebug builds before the HAL initializes. `Init` calls `umount()` on `DebugFS` when the device has completed booting. |\n| **Bugreport generation** : The dumpstate HAL reads `DebugFS` files, which become part of the bug report. | Done by dumpstate HAL within `DumpstateBoard()` when invoked by dumpstate ([DumpstateDevice.cpp](https://cs.android.com/android/platform/superproject/+/android-latest-release:device/google/trout/hal/dumpstate/1.1/DumpstateDevice.cpp)). The dumpstate tool (part of the Android framework) ensures that `DebugFS` mounts during the invocation. |\n| **Device-specific testing and validation** | Adb root and shell. Mount `DebugFS` from the adb shell with root access^1^. |\n\n\n^1^To mount `DebugFS` from `adb shell` with\nroot access, use this command:\n\n`adb shell mount -t debugfs debugfs /sys/kernel/debug`.\n| **Note:**\n|\n| - **Android 12: There aren't any new APIs for accessing the\n| dumpstate HAL**.\n| - **Android 12: New clients don't have access** to the dumpstate HAL.\n| - Only the dumpstate HAL process and vendor-modprobe tool can access `DebugFS` for Android 12 launching devices, since the kernel modules it loads might create `DebugFS` files.\n\nRequired partner actions\n------------------------\n\n\nPartners must enact the following based on these changes in\nAndroid 12 devices:\n\n- Make all boot time initializations of `DebugFS` nodes happen during the dumpstate HAL initialization. For an example of how to do this, see [DNM:\n Example for boot time initialization of `DebugFS` files](https://android-review.googlesource.com/c/platform/hardware/interfaces/+/1426054).\n- **Don't allow `DebugFS` access during runtime. The following exceptions\n apply:**\n - Bugreport generation (comes from the dumpstate HAL)\n - Testing and validation (accessible by `adb root` and `shell` - ensure that DebugFS is mounted first)\n\nDevelopers can set the debug persistent property\n`persist.dbg.keep_debugfs_mounted` to keep `DebugFs` mounted across\nreboots on userdebug and eng builds.\n\nGTS compliance tests ensure that the `DebugFS` filesystem isn't\nmounted in user builds. Sepolicy `neverallow` statements ensure that in devices\nlaunching on Android 12 or higher, unauthorized processes aren't provided\naccess to `DebugFs`."]]
