Construyendo un módulo kernel de Linux fuera de árbol en un directorio de objetos separado

Question

Estoy confrontando el sistema de compilación del kernel de Linux (Kbuild, kernel ≥2.6.28) con la estructura de directorios y el sistema de compilación para un proyecto más grande. Nuestro proyecto contiene un módulo del núcleo Linux fuera del árbol, y nuestra estructura de directorios se parece a esto (simplificado, obviamente):

checkout/src/common/*.c   source files (common to Linux and other platforms) 
checkout/src/linux-driver/*.c  source files (for the Linux kernel driver) 
checkout/build/linux/Kbuild  Kbuild 
tmp/linux-2.6.xx/     where the Linux kernel is unpacked and configured 
output/linux-arm-debug/   where object files must end up 

El proceso de construcción No hay que modificar nada bajo checkout, y construir el módulo debe no modificar nada en tmp/linux-2.6.xx. Todos los archivos de salida deben terminar en output/linux-arm-debug (o cualquier variante de arquitectura y depuración que se haya seleccionado en el momento de la compilación).

He leído kbuild/modules.txt, y empecé a escribir mi archivo Kbuild:

MOD_OUTPUT_DIR = ../../../output/linux-$(ARCH)-$(DEBUG) 
obj-m += $(MOD_OUTPUT_DIR)/foo_mod.o 
$(MOD_OUTPUT_DIR)/our_module-objs := $(MOD_OUTPUT_DIR)/foo_common.o $(MOD_OUTPUT_DIR)/foo_linux.o 

Este se encarga de almacenar los ficheros objeto en un directorio diferente de donde Kbuild vidas. Ahora, ¿cómo puedo especificar que foo_common.o necesita ser compilado desde …/checkout/src/common/foo_common.c y foo_linux.o desde …/checkout/src/linux-driver/foo_linux.c?

Answer 1

Si bien no ha mencionado lo que ha intentado hasta ahora (o si ya encontró una solución), parece que solo necesita continuar un poco más abajo en el archivo modules.txt - a Sección 4.3:

--- 4.3 Several Subdirectories 

kbuild can handle files that are spread over several directories. 
Consider the following example: 

. 
|__ src 
| |__ complex_main.c 
| |__ hal 
| |__ hardwareif.c 
| |__ include 
|  |__ hardwareif.h 
|__ include 
    |__ complex.h 

To build the module complex.ko, we then need the following 
kbuild file: 

    --> filename: Kbuild 
    obj-m := complex.o 
    complex-y := src/complex_main.o 
    complex-y += src/hal/hardwareif.o 

    ccflags-y := -I$(src)/include 
    ccflags-y += -I$(src)/src/hal/include 

As you can see, kbuild knows how to handle object files located 
in other directories. The trick is to specify the directory 
relative to the kbuild file's location. That being said, this 
is NOT recommended practice. 

For the header files, kbuild must be explicitly told where to 
look. When kbuild executes, the current directory is always the 
root of the kernel tree (the argument to "-C") and therefore an 
absolute path is needed. $(src) provides the absolute path by 
pointing to the directory where the currently executing kbuild 
file is located. 

Answer 2

Mi solución poco elegante pero eficaz es copiar los archivos de origen en el árbol de salida.

FOO_SOURCES_DIR = $(src)/../../../checkout/src 
FOO_MOD_OUTPUT_DIR = ../../../output/linux-$(ARCH)-$(DEBUG) 

# Specify the object files 
obj-m += $(FOO_MOD_OUTPUT_DIR)/foo_mod.o 
FOO_MODULE_OBJS := $(FOO_MOD_OUTPUT_DIR)/foo_common.o $(FOO_MOD_OUTPUT_DIR)/foo_linux.o 
$(FOO_MOD_OUTPUT_DIR)/foo_mod-objs := $(FOO_MODULE_OBJS) 

# Where to find the sources 
$(src)/$(FOO_MOD_OUTPUT_DIR)/foo_common.c: $(FOO_SOURCES_DIR)/common/foo_common.c 
$(src)/$(FOO_MOD_OUTPUT_DIR)/foo_linux.c: $(FOO_SOURCES_DIR)/linux-driver/foo_linux.c 

# Rules to copy the sources 
FOO_COPIED_SOURCES = $(patsubst %.o,$(src)/%.c,$(FOO_MODULE_OBJS)) 
$(FOO_COPIED_SOURCES): 
     $(Q)mkdir -p $(@D) 
     cp -f $< $@ 
clean-files += $(FOO_COPIED_SOURCES) 
clean-dirs += $(FOO_MOD_OUTPUT_DIR) 

Answer 3

Un poco tarde, pero parece que O= flag es lo que necesita.

Answer 4

Puede establecer la variable de entorno KBUILD_OUTPUT. Esto funciona de manera similar a la opción O=; sin embargo, dado que es una variable de entorno, puede abarcar múltiples archivos make donde no se puede pasar O= o necesita construirse un módulo fuera de directorio. Estaba teniendo el mismo problema al tratar de crear un conjunto de módulos compat-wireless y necesitaba usar O= para la construcción real de la imagen del kernel.

Answer 5

Tuve un problema similar. Modifiqué linux_2_6_34/scripts/Makefile.build de la siguiente manera.

ifdef SRCDIR 
src := $(SRCDIR) 
else 
src := $(obj) 
endif 

SRCDIR es el origen de directorio.

para compilar el módulo y como realizar

make -c $(KDIR) M=$(Your_output_dir) SRCDIR=$(your source directory)` 

Answer 6

Aquí es un Makefile, que hace de fuente de árboles construye para los módulos de kernel de árboles (adaptado de @ comentarios de Mark) ...

KDIR ?= /lib/modules/$(shell uname -r)/build 
BUILD_DIR ?= $(PWD)/build 
BUILD_DIR_MAKEFILE ?= $(PWD)/build/Makefile 

default: $(BUILD_DIR_MAKEFILE) 
    make -C $(KDIR) M=$(BUILD_DIR) src=$(PWD) modules 

$(BUILD_DIR): 
    mkdir -p "$@" 

$(BUILD_DIR_MAKEFILE): $(BUILD_DIR) 
    touch "$@" 

clean: 
    make -C $(KDIR) M=$(BUILD_DIR) src=$(PWD) clean 

Nota: Usted todavía necesita un archivo kbuild ...

obj-m += my_driver.o