Cargando el módulo kernel en el núcleo de Android

Question

Estoy haciendo una lista de mi problema aquí.

Tengo un teléfono Google Nexus one a.k.a. "pasión" conmigo. Las herramientas Fastboot y adb están instaladas en el teléfono. Y el cargador de arranque está desbloqueado.

Mi tarea: Tengo que agregar un módulo de kernel de Linux al kernel de Android.

Lo que he hecho:

He seguido los pasos en http://source.android.com/source/initializing.html y descargado el kernel para android-2.3.6_r1 (pasión) y se han construido. También puedo mostrarlo en el teléfono y el nuevo kernel de Android también funciona bien. Ahora lo que quiero es modificar el kernel y agregar mi propio módulo kernel y luego flashearlo en el teléfono, para que el núcleo en el teléfono sea mi kernel modificado.

Ahora he encontrado dos enfoques para hacer esto.

1)

Cruz compilar mi módulo del núcleo con el núcleo androide y empuje en el dispositivo con el comando adb. El Makefile que uso en el kernel es el siguiente.

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 

Ahora esto no puede generar nuevos hello-1.ko. No sé por qué, creo que hay algún problema con los valores VERSION, PATCHLEVEL, SUBLEVEL y EXTRAVERSION. ¿Son necesarios? Intenté este valor de android-2.3.6_r1 también pero todavía no funciona. No estoy seguro de qué es este valor de EXTRAVERSIÓN?

Incluso probé con el hello-1.ko generado a partir del compilador en mi ubuntu. Empujé este hello-1.ko al emulador con el siguiente 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 

Pero hello-1.ko no puede insmod y aparece el siguiente error. insmod: Error en init_module() la función hello-1.ko no implementado

Considerando que el hola-1.c es bastante simple:

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

El segundo método de hacer esto puede colocar mis archivos fuente del módulo kernel en el directorio kernel de android. Puede estar en el directorio del sistema o en otro lugar y pedir al make que cree estos archivos fuente junto con la otra fuente. Pero no estoy seguro de dónde pedirle al proceso de make que lo haga. Intenté hacerlo en main.mk y creé un archivo Android.mk en el directorio fuente de mis archivos fuente, pero no funcionó. Puede ser esta es una solución mejor, pero no pude encontrar ninguna ayuda en esto.

Después de hacer esto, los módulos de mi kernel deben poder controlar el wnic (dispositivo de interfaz de red inalámbrica) del teléfono Android. Debería poder poner el wnic en modo de suspensión y luego reactivarlo después de recibir el comando de mi módulo kernel. Si tiene algunos consejos sobre cómo hacer esto, será una ayuda. Descubrí que en Android se controla mediante el controlador privado wpa_supplicant. Comandos, como:

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

puede hacer mi tarea, pero no estoy seguro ya que no he intentado. No he llegado a esa etapa.

Mire esto y proporcione ayuda/orientación.

Gracias,

Apurva

Answer 1

módulos del kernel (KO) son mucho más fáciles de trabajar que un kernel estático - siempre y cuando el kernel les ha permitido. La forma más fácil de decir es hacer un "adb shell lsmod". La segunda es ver si el kernel .config ha habilitado CONFIG_MODULES = y y CONFIG_MODULE_UNLOAD = y. Mucha información en la web sobre el desarrollo de Linux KO.

Hummm, que está cerca, pero parece que el makefile es chiflado. Primero intente construir el hello KO en su host para la prueba unitaria, luego construya sobre su objetivo. A continuación se muestra un makefile que uso en un pan de jengibre corriendo 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

primer cheque en el .config si el soporte de módulos está activado. (CONFIG_MODULES = y y CONFIG_MODULE_UNLOAD = y) si no los habilita usando menuconfig.

A continuación, coloque el módulo sobre la raíz de la fuente del núcleo y añadir esto a la makefile principal se encuentra en la raíz

core-y  := usr/ yourModule/ 

y esto a las carpetas yourModule makefile

obj-m := yourModule.o