8 votos

Scott Severance avatar

¿Cuál es el formato de los registros de Android?

Preguntado el 1 de Octubre, 2012
Cuando se hizo la pregunta
2838 visitas
Cuantas visitas ha tenido la pregunta
2 Respuestas
Cuantas respuestas ha tenido la pregunta
Resuelta
Estado actual de la pregunta

Estoy tratando de recopilar datos sobre mi teléfono mediante el análisis de los archivos de registro en /dev/log . Estoy buscando específicamente /dev/log/main . Siempre pensé que cualquier formato de registro sensato sería de texto plano, pero estos archivos parecen ser binarios o en algún conjunto de caracteres que ni yo ni mis editores de texto de Linux podemos identificar.

¿Cuál es el formato?

Aquí hay un par de capturas de pantalla:

  • En primer lugar, he aquí un fragmento del registro interpretado por vim ( ^@ se refiere al byte nulo; no estoy seguro de las otras secuencias de control de color): vim

  • A continuación, este es el aspecto del registro en un editor hexadecimal: hex editor

Estoy usando un Galaxy Nexus con Jelly Bean. Los registros se recogieron utilizando Root y un emulador de terminal, ya que aLogcat no parece utilizar Root y por lo tanto no puede acceder a toda la información de registro.

Preguntado el 1 de Octubre, 2012 por Scott Severance

Respuestas

¿Demasiados anuncios?

6voto

Izzy avatar
Izzy Puntos 45544

Si quieres información sana, te recomiendo comandos sanos :) (sin ánimo de ofender, es una broma). Así que la pregunta debería decir:

¿Cómo obtener información de registro de un dispositivo Android?

Y ahora estamos en el mejor lado. Hay múltiples enfoques que se pueden utilizar:

  • utilizar aplicaciones para mostrar información de registro (codificada por colores)
  • utilizar ADB (parte del SDK de Android) para extraer remotamente la misma información
  • utilizar ssh desde el remoto (o una aplicación de terminal local) para obtener la información directamente del dispositivo

Para tratar a fondo este tema se necesita algo más que esta simple respuesta (si está interesado, puede encontrar información más detallada en muchos sitios web, o en el libro de Andrew Hoog Forense de Android: Investigación, análisis y seguridad móvil para Google Android que tuve el honor de traducir al alemán. Seguramente también hay muchas otras fuentes.

Así que sólo daré algunos ejemplos para que empieces:

Utilización de aplicaciones

La aplicación probablemente más conocida en este contexto es aLogcat disponible de forma gratuita en la playstore (y el desarrollador aceptará gustosamente su donación para la otra variante de la misma aplicación). Encontrarás una captura de pantalla a continuación 1 . La aplicación le permite filtrar los registros, iniciar/detener la grabación de los mensajes de registro, e incluso almacenar los fragmentos grabados en su tarjeta SD - por supuesto en texto plano, como usted solicitó.

Otra aplicación de esta sección es Colector de registros que simplemente trata de agarrar todo el registro disponible y enviarlo a través del menú de compartir 2 .

aLogCatLog Collector

El puente de depuración de Android (ADB)

El kit de desarrollo de software de Android (SDK) incluye el adb para diversas tareas. Entre otras muchas, ofrece la adb shell para ejecutar comandos en el dispositivo. Usando esto, usted puede reunir su información de registro deseada también: Sólo tiene que anteponer a los siguientes comandos adb shell .

Indicación de comandos en el dispositivo

Utilizando una aplicación de terminal (por ejemplo Emulador de terminal Android o Terminal IDE ) puedes acceder a los registros directamente en el símbolo del sistema, localmente en tu dispositivo. Un poco más cómodo, esto se puede hacer ejecutando un servidor ssh (por ejemplo DroidSSHd o Servidor DropBear SSH ) en su dispositivo, y acceder a él desde su ordenador. Así podrás trabajar en una pantalla grande, mientras investigas tus registros.

Comandos para acceder a su información de registro

Hay muchos comandos poderosos que puedes usar para acceder a tu información de registro desde la línea de comandos, y aquí sólo daré algunos ejemplos.

dmesg

El dmesg extrae el registro del kernel:

$ dmesg
<6>[82839.126586] PM: Syncing filesystems ... done.
<7>[82839.189056] PM: Preparing system for mem sleep
<4>[82839.189361] Freezing user space processes ... (elapsed 0.05 seconds) done.
<4>[82839.240661] Freezing remaining freezable tasks ... (elapsed 0.00 seconds) done.
<7>[82839.242279] PM: Entering mem sleep
<4>[82839.242889] Suspending console(s) (use no_console_suspend to debug)
<7>[82839.252410] vfp_pm_save_context: saving vfp state
<6>[82839.252716] PM: Resume timer in 26 secs (864747 ticks at 32768 ticks/sec.)
<6>[82842.091369] Successfully put all powerdomains to target state
<6>[82842.092468] wakeup wake lock: wifi_wake

logcat

Con logcat , puedes acceder a mucha información de registro -- pero la mayoría de las veces, esto requerirá Root. Tiene algunos parámetros para filtrar la información, por ejemplo, seleccionando el buffer de registro a leer con -b . Por favor, lea la información proporcionada en el página de desarrolladores en logcat para más detalles. Por poner dos ejemplos: logcat -b events se enumerarían los eventos, o logcat -b radio información sobre el módulo de radio de su dispositivo.

dumpsys y dumpstate

Los dos comandos dumpsys y dumpstate le ofrece información detallada del sistema:

$ dumpsys
Currently running services:
    LocationProxyService
    SurfaceFlinger
    accessibility
    account
    activity
<snip>
DUMP OF SERVICE account:
Accounts: 1
    Account {name=xxxxxxx@googlemail.com, type=com.google}
<snip>
DUMP OF SERVICE alarm:

$ dumpstate
========================================================
== dumpstate: 2012-08-18 23:39:53
========================================================
Build: Gingerbread GWK74 - CyanogenMilestone2
Bootloader: 0x0000
Radio: unknown
<snip>
------ MEMORY INFO (/proc/meminfo) ------
MemTotal: 487344 kB
MemFree:   10436 kB
Buffers:   14136 kB
Cached:    145460 kB
<snip>

informe de errores

Y si te da pereza recordarlos todos, simplemente utiliza el bugreport que llama a todo lo anterior y lo agrupa para un bonito, humm, informe de errores al desarrollador...

Por supuesto, puedes redirigir la salida de todos esos comandos a un archivo para copiarlo en tu ordenador, y en la mayoría de los casos deberías hacerlo - ya que tu buffer de pantalla sería demasiado pequeño para manejarlo todo: bugreport > /mnt/sdcard/bugreport.txt sería un ejemplo para esa parte.

Respondido el 1 de Octubre, 2012 por Izzy (45544 Puntos )

4voto

Lekensteyn avatar
Lekensteyn Puntos 568

Para los desarrolladores (u otros interesados) que necesiten analizar este archivo sin procesar, he aquí algunos recursos:

El formato real del registro se detalla en:

Una copia de las partes pertinentes, ligeramente anotada y reordenada para su comodidad:

#define LOGGER_ENTRY_MAX_LEN (5*1024)

struct log_msg {
    union {
        /* Maximum size of entry: 5121 bytes */
        unsigned char buf[LOGGER_ENTRY_MAX_LEN + 1];

        struct logger_entry_v3 entry;
        struct logger_entry_v3 entry_v3;
        struct logger_entry_v2 entry_v2;
        struct logger_entry entry_v1;
    } __attribute__((aligned(4)));
}
/*
 * The userspace structure for version 1 of the logger_entry ABI.
 * This structure is returned to userspace by the kernel logger
 * driver unless an upgrade to a newer ABI version is requested.
 */
struct logger_entry {
    uint16_t    len;    /* length of the payload */
    uint16_t    __pad;  /* no matter what, we get 2 bytes of padding */
    int32_t     pid;    /* generating process's pid */
    int32_t     tid;    /* generating process's tid */
    int32_t     sec;    /* seconds since Epoch */
    int32_t     nsec;   /* nanoseconds */
    char        msg[0]; /* the entry's payload */
} __attribute__((__packed__));

/*
 * The userspace structure for version 2 of the logger_entry ABI.
 * This structure is returned to userspace if ioctl(LOGGER_SET_VERSION)
 * is called with version==2; or used with the user space log daemon.
 */
struct logger_entry_v2 {
    uint16_t    len;    /* length of the payload */
    uint16_t    hdr_size; /* sizeof(struct logger_entry_v2) */
    int32_t     pid;    /* generating process's pid */
    int32_t     tid;    /* generating process's tid */
    int32_t     sec;    /* seconds since Epoch */
    int32_t     nsec;   /* nanoseconds */
    uint32_t    euid;   /* effective UID of logger */
    char        msg[0]; /* the entry's payload */
} __attribute__((__packed__));

struct logger_entry_v3 {
    uint16_t    len;    /* length of the payload */
    uint16_t    hdr_size; /* sizeof(struct logger_entry_v3) */
    int32_t     pid;    /* generating process's pid */
    int32_t     tid;    /* generating process's tid */
    int32_t     sec;    /* seconds since Epoch */
    int32_t     nsec;   /* nanoseconds */
    uint32_t    lid;    /* log id of the payload */
    char        msg[0]; /* the entry's payload */
} __attribute__((__packed__));

Puedes distinguir las versiones de las diferencias mirando el tercer y el cuarto byte. Al parecer, el formato también depende del ancho de banda de su plataforma. Para los mensajes v1, __pad es igual a 0 . los mensajes v2 (y v3) utilizan 24 ( 0x18 ).

Para main , radio y system Registros msg se interpreta de la siguiente manera ( fuente ):

  • prioridad: 1 byte
  • etiqueta: 0 o más bytes
  • literalmente \0 como separador
  • mensaje: 0 o más bytes
  • literalmente \0 como terminador

Si este mensaje está truncado, la parte final \0 puede faltar.

Para events Sin embargo, el registro, msg contienen los siguientes datos binarios:

  • Etiqueta: Clave entera de 4 bytes del archivo "/system/etc/event-log-tags".
  • Mensaje: árbol serializado a partir del nodo root. Cada nodo del árbol comienza con un valor de 1 byte de la enumeración AndroidEventLogType:
    • EVENT_TYPE_INT - el valor del nodo es un entero de 4 bytes
    • EVENT_TYPE_LONG - el valor del nodo es un entero de 8 bytes
    • EVENT_TYPE_STRING - el valor del nodo es un entero de 4 bytes length , seguido por el length bytes que contienen una cadena codificada en UTF8
    • EVENT_TYPE_LIST - el valor del nodo es de un solo byte length , seguido por el length nodos del árbol, cada uno con su propio AndroidEventLogType .
Respondido el 22 de Junio, 2014 por Lekensteyn (568 Puntos )

Preguntas relacionadas

Preguntas Destacadas

Etiquetas mas usadas

En nuestra red

PreguntAndroid.com

PreguntAndroid es una comunidad de usuarios de Android en la que puedes resolver tus problemas y dudas.
Puedes consultar las preguntas de otros usuarios, hacer tus propias preguntas o resolver las de los demás.

Powered by:

Yandex
X