Caricamento modulo kernel nel kernel Android

Question

Sto elencando il mio problema qui.

Ho un telefono Google Nexus a.k.a. "passione" con me. Gli strumenti fastboot e adb sono installati nel telefono. E il boot loader è sbloccato.

Il mio compito: devo aggiungere un modulo del kernel linux al kernel di Android.

Quello che ho fatto:

ho seguito la procedura descritta in http://source.android.com/source/initializing.html e scaricato il kernel per Android-2.3.6_r1 (passione) e hanno costruito. Sono anche in grado di farlo lampeggiare sul telefono e anche il nuovo kernel di Android funziona bene. Ora quello che voglio è modificare il kernel e aggiungere il mio modulo del kernel e poi farlo lampeggiare sul telefono, in modo che il kernel sul telefono sia il mio kernel modificato.

Ora mi sono imbattuto in due approcci per farlo.

1)

Croce Compilare il mio modulo del kernel con il kernel Android e spingerlo sul dispositivo con il comando adb. Il Makefile che uso nel kernel è il seguente.

VERSION = 2 
PATCHLEVEL = 3 
SUBLEVEL = 6 
EXTRAVERSION = -00054-g5f01537 
obj-m += hello-1.o 
KDIR=/home/apurva/android_dir 
PWD := $(shell pwd) 
all: 
     make -C $(KDIR) ARCH=arm CROSS_COMPILE=/home/apurva/android_dir/prebuilt/linux- x86/toolchain/arm-eabi-4.4.0/bin/arm-eabi- SUBDIRS=$(PWD) modules 

clean: 
     make -C $(KDIR) ARCH=arm CROSS_COMPILE=/home/apurva/android_dir/prebuilt/linux-x86/toolchain/arm-eabi-4.4.0/bin/arm-eabi- SUBDIRS=$(PWD) clean 

Ora questo non è in grado di generare nuovo ciao-1.ko. Non so perché, immagino ci sia qualche problema con i valori VERSION, PATCHLEVEL, SUBLEVEL e EXTRAVERSION. Sono necessari? Ho provato questi valori anche da Android 2.3.6_r1, ma ancora non funziona. Non sono sicuro di quale sia questo valore EXTRAVERSION?

Ho anche provato con l'hello-1.ko generato dal compilatore nella mia ubuntu. Ho spinto questo ciao-1.ko nell'emulatore con il seguente comando adb.

/root/bin/src/out/host/linux-x86/bin/adb shell mount 
/root/bin/src/out/host/linux-x86/bin/adb push hello-1.ko /data 
/root/bin/src/out/host/linux-x86/bin/adb insmod /data/hello-1.ko 

Ma che ciao-1.ko non è in grado di insmod e ottengo il seguente errore. insmod: Errore nella init_module() la funzione ciao-1.ko non implementato

considerando che il ciao-1.c è abbastanza semplice:

#include <linux/module.h>  /* Needed by all modules */ 
#include <linux/kernel.h>  /* Needed for KERN_INFO */ 

int init_module(void) 
{ 
     printk(KERN_INFO "Hello world 1.\n"); 
     return 0; 
} 

void cleanup_module(void) 
{ 
    printk(KERN_INFO "Goodbye world 1.\n"); 
} 

2)

Il secondo approccio di fare questo può mettere i miei file sorgente del modulo del kernel nella directory del kernel di Android. Può trovarsi nella directory di sistema o altrove e chiedere al produttore di creare questi file sorgente insieme all'altra fonte. Ma non sono sicuro di dove chiedere il processo decisionale per farlo. Ho provato a farlo in main.mk e ho creato un file Android.mk nella directory sorgente dei miei file sorgente ma non ha funzionato. Potrebbe essere questa una soluzione migliore ma non ho trovato alcun aiuto su questo.

Dopo aver eseguito questa operazione, i miei moduli del kernel dovrebbero essere in grado di controllare il wnic (dispositivo di interfaccia di rete wireless) del telefono Android. Dovrebbe essere in grado di mettere il wnic in modalità sleep e quindi riattivarlo dopo aver ricevuto il comando dal mio modulo del kernel. Se hai delle indicazioni su come farlo, sarà un aiuto. Ho scoperto che su Android è controllato tramite il driver privato wpa_supplicant. Comandi, come:

wpa_cli driver powermode 0 - auto 
wpa_cli driver powermode 1 - active 

possono eseguire il mio compito, ma non sono sicuro poiché non ho provato. Non ho raggiunto quel livello.

Si prega di esaminare questo e fornire qualche aiuto/guida.

Grazie,

Apurva

Answer 1

I moduli del kernel (KO) sono molto più facili da lavorare rispetto un kernel statica - fino a quando il kernel ha consentito loro. Il modo più semplice per dire è "adb shell lsmod". Secondo è vedere se il kernel .config ha abilitato CONFIG_MODULES = y e CONFIG_MODULE_UNLOAD = y. Un sacco di informazioni sul web sullo sviluppo di KO linux.

Hummm, sei vicino ma sembra che il makefile sia fottuto. Prima prova a costruire il Ciao KO sul tuo host per il test dell'unità, quindi costruisci sul tuo obiettivo. Ecco un makefile di esempio che uso su un pan di zenzero in esecuzione OMAP36xx:

# Makefile for trivial android kernel module 

obj-m += mod_hello.o 

CROSS_COMPILE=/opt/distros/ARM/bin/arm-none-linux-gnueabi- 
TARG_KDIR ?= /opt/android/dal/nook_kernel 

HOST_KDIR=/lib/modules/$(shell uname -r)/build 

# target creates: 
# .<obj>.o: CC command line for the .o, including dependencies 
# .<obj>.mod.o.cmd: CC command line for the mod.o, including dependencies 
# .<obj>.ko.cmd: LD command line which links the .o and .mod.o to create the .ko 
target: 
    @echo "Make module for target arm" 
    make -C $(TARG_KDIR) M=$(PWD) ARCH=arm CROSS_COMPILE=$(CROSS_COMPILE) modules 

host: 
    @echo "Make module for host" 
    make -C $(HOST_KDIR) M=$(PWD) modules 

clean: 
    @echo "cleaning target" 
    make -C $(TARG_KDIR) M=$(PWD) clean 
    @echo "cleaning host" 
    make -C $(HOST_KDIR) M=$(PWD) clean 

Answer 2

primo controllo nella config se il supporto modulo è abilitato. (CONFIG_MODULES = y e CONFIG_MODULE_UNLOAD = y) se non li abiliti usando menuconfig.

Poi posizionare il modulo sul radice della sorgente del kernel e aggiungere questo al makefile principale si trova alla radice

core-y  := usr/ yourModule/ 

e questo per le cartelle nomemodulo MAKEFILE

obj-m := yourModule.o