Sto cercando di raccogliere dati sul mio telefono analizzando i file di registro /dev/log. Sto specificamente guardando /dev/log/main. Ho sempre pensato che qualsiasi formato log logico sarebbe un testo semplice, ma questi file sembrano essere binari o in un set di caratteri che né io né i miei editor di testi Linux possiamo identificare.

Qual è il formato?

Ecco un paio di schermate:

• Innanzitutto, ecco un frammento del registro come interpretato da vim(si ^@riferisce al byte null; non sono sicuro delle altre sequenze di controllo colorate):

• Quindi, ecco come appare il registro in un editor esadecimale:

Sto usando un Galaxy Nexus con Jelly Bean. I log sono stati raccolti usando root e un emulatore di terminale, poiché aLogcat non sembra usare root e quindi non può accedere a tutte le informazioni di registrazione.

Se vuoi informazioni sane, ti consiglio comandi sani :) (nessuna offesa significava solo scherzare). Quindi la domanda dovrebbe essere:

Come ottenere le informazioni di registro da un dispositivo Android?

E ora siamo dalla parte migliore. Esistono diversi approcci che possono essere utilizzati:

• utilizzare le app per visualizzare le informazioni del registro (con codice colore)
• utilizzare ADB (parte dell'SDK Android) per estrarre in remoto le stesse informazioni
• usa ssh dal telecomando (o un'app terminale locale) per acquisire le informazioni direttamente dal dispositivo

Per gestire completamente questo argomento ci vuole più di questa semplice risposta (se interessati, ad esempio puoi trovare informazioni più dettagliate su molti siti Web o nel libro di Andrew Hoog Android Forensics: Investigation, Analysis and Mobile Security for Google Android , di cui ho avuto il onore di tradurre in tedesco. Probabilmente ci sono anche molte altre fonti.

Quindi ti darò solo alcuni esempi qui per iniziare:

Utilizzo di app

L'app probabilmente più conosciuta in questo contesto è aLogcat , disponibile gratuitamente nel playstore (e lo sviluppatore accetterà felicemente la tua donazione per l'altra variante della stessa app). Di seguito troverai uno screenshot ¹ . L'app ti consente di filtrare i log, di avviare / interrompere la registrazione dei messaggi di log e persino di archiviare gli snippet registrati sulla tua scheda SD, ovviamente in testo semplice, come richiesto.

Un'altra app in questa sezione è Log Collector , che cerca semplicemente di afferrare l'intero registro disponibile e inviarlo tramite il menu di condivisione ² .

Android Debug Bridge (ADB)

Android Software Development Kit (SDK) include il adbcomando per varie attività. Tra gli altri, offre l' adb shellesecuzione di comandi sul dispositivo. Usando questo, puoi anche raccogliere le informazioni di registro desiderate: basta un prefisso sotto i comandi con adb shell.

Prompt dei comandi sul dispositivo

Utilizzando un'app terminale (ad esempio Android Terminal Emulator o Terminal IDE ) è possibile accedere ai registri direttamente dal prompt dei comandi, localmente sul dispositivo. Un po 'più comodo, questo può essere fatto eseguendo un server SSH (ad esempio DroidSSHd o DropBear SSH Server ) sul tuo dispositivo e accedendo dal tuo computer. In questo modo puoi lavorare su un grande schermo, mentre analizzi i tuoi registri.

Comandi per accedere alle informazioni del registro

Ci sono molti comandi potenti che puoi usare per accedere alle informazioni del tuo registro dalla riga di comando, e qui darò solo alcuni esempi.

dmesg

Il dmesgcomando estrae il 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, è possibile accedere a molte informazioni di registrazione, ma la maggior parte delle volte ciò richiederà root. Ha alcuni parametri per filtrare le informazioni, ad esempio selezionando il buffer di registro con cui leggere -b. Per i dettagli, leggere le informazioni fornite nella pagina degli sviluppatori su logcat . Per darti due esempi: logcat -b eventselenca eventi o logcat -b radioinformazioni sul modulo radio del tuo dispositivo.

dumpsys e dumpstate

I due comandi dumpsyse dumpstateforniscono informazioni dettagliate sul 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>

riportare un errore

E se sei troppo pigro per ricordarli tutti, usa semplicemente il bugreportcomando - che chiama tutto sopra e lo raggruppa per una bella, umile, segnalazione di bug allo sviluppatore ...

Ovviamente, puoi reindirizzare l'output da tutti quei comandi a un file per copiarlo sul tuo computer, e nella maggior parte dei casi dovresti farlo - poiché il buffer dello schermo sarebbe troppo piccolo per gestirlo tutto: bugreport > /mnt/sdcard/bugreport.txtsarebbe un esempio per quella parte.

Per gli sviluppatori (o altre parti interessate) che devono analizzare questo file non elaborato, ecco alcune risorse:

• logcat (il programma che può generare registri binari), chiama android_logger_list_read()per raccogliere le voci del registro: https://android.googlesource.com/platform/system/core/+/master/logcat/logcat.cpp
• Informazioni sulla registrazione di Android in generale: http://elinux.org/Android_Logging_System
• La libreria di registrazione di basso livello per la lettura / scrittura dei registri: https://android.googlesource.com/platform/system/core/+/master/liblog
• Un'utilità per scaricare registri non elaborati (binari), cambiando facoltativamente le versioni: https://lekensteyn.nl/files/logread.c
• Fonte del kernel per logger: https://github.com/android/kernel_common/blob/android-3.10/drivers/staging/android/logger.c

Il formato effettivo del formato del registro è dettagliato in:

• https://android.googlesource.com/platform/system/core/+/master/include/log/logger.h

Una copia delle parti pertinenti, leggermente annotata e riordinata per comodità:

#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__));

È possibile distinguere le versioni delle differenze osservando il terzo e il quarto byte. Apparentemente il formato dipende anche dall'endianità della tua piattaforma. Per i messaggi v1, è __paduguale a 0. i messaggi v2 (e v3) usano 24 ( 0x18).

Per main, radioe systemtronchi msgcampo viene interpretato come segue ( fonte ):

• priorità: 1 byte
• tag: 0 o più byte
• letterale \0come separatore
• messaggio: 0 o più byte
• letterale \0come terminatore

Se questo messaggio viene troncato, il trailing \0potrebbe mancare.

Per il eventsregistro, tuttavia, il msgcampo contiene i seguenti dati binari:

• Tag: chiave intera di 4 byte dal file "/ system / etc / event-log-tags".
• Messaggio: albero serializzato a partire dal nodo principale. Ogni nodo dell'albero inizia con un valore di 1 byte dall'enumerazione AndroidEventLogType:
  • EVENT_TYPE_INT - il valore del nodo è 4 byte interi
  • EVENT_TYPE_LONG - il valore del nodo è 8 byte interi
  • EVENT_TYPE_STRING - il valore del nodo è un numero intero di 4 byte length, seguito dai lengthbyte che contengono una stringa codificata UTF8
  • EVENT_TYPE_LIST - il valore del nodo è un byte singolo length, seguito dai lengthnodi dell'albero ciascuno dei suoi AndroidEventLogType.