Compilar módulo do kernel para Raspberry Pi

Devido a uma determinada condição, decidi fazer esse tutorial "soft-level" para adicionar o suporte ao sistema de arquivos XFS do kernel para sistemas Linux sem tal suporte, mas poderia ser qualquer outro modulo ou driver, basta seguir o raciocínio.

Antes de mais, eu utilizo o Raspbian (que já tem o suporte habilitado) e não tenho paciência para testar em outras boards nem outros sistemas, portanto, use esse artigo como base, mas não espere que ele seja algo genérico porque certamente não é. Escrevi diversas possibilidades para tornar o mais flexível possível de modo que esse tutorial possa ser utilizado em diversas plataformas, mas não agradará gregos e troianos.

Pré-requisitos

Você deve ter o programa make e o gcc instalados em seu sistema, além da libncurses, bc e build-essentials:

apt-get install make gcc libncursesw5-dev build-essentials bc

Módulo ou built-in

Quando você compila um suporte built-in, significa que o kernel tem suporte estático, sem depender da carga de módulos. Desse modo, o kernel fica um pouco maior, mas o tipo de compilação depende de alguns critérios. Como o foco agora é mostrar a compilação de um módulo independente, vou tentar ater-me a isso sem discorrer sobre toda a estrutura.

Para adicionar o suporte a 1 módulo, alguns passos serão necessário antes dos "finalmentes". Baixar a versão do kernel em execução é uma delas. Você pode tentar com outra versão, mas a possibildade de dar erros é grande.

Se quiser compilar built-in, é outra história e você deverá compilar o kernel inteiro, não apenas o módulo.

Baixar o kernel

A melhor opção é que você tenha a versão do kernel já nos repositórios de sua distribuição. Sendo ela baseada em Debian (Emdebian, Raspbian, Minibian, Ubuntu etc), procure pelos fontes no repositório:

apt-cache search linux| grep source

E para ver a versão que está em execução:

uname -r

Se tiver essa versão no repositório, instale-a. Supondo a versão 4.1.17-v7+:

sudo apt-get install linux-source-4.1.17-v7+

Após instalado, o kernel se encontrará em /usr/src/linux-$VERSAO_ESCOLHIDA

Faça já um link simbólico para facilitar as coisas:

sudo su
ln -s /usr/src/linux-4.1.17-v7+ /usr/src/linux

No meu caso, eu não tinha essa versão do kernel por isso baixei a mais atual do kernel.org, diretamente no diretório /usr/src:

wget -c https://cdn.kernel.org/pub/linux/kernel/v4.x/linux-4.5.4.tar.xz
tar xvJf linux-4.5.4.tar.xz
apt-get install libncursesw5-dev
ln -s /usr/src/linux-4.5.4 /usr/src/linux && cd /usr/src/linux

Como você pode reparar aí em cima, já aproveitei pra instalar a lib ncurses-dev, fundamental para a criação do menu gráfico do kernel, mas eu o citei nos pré-requisitos lá no começo do post.

A outra opção para o Raspberry é baixar o kernel do github do projeto. Acredito que seja a opção mais adequada. Nesse caso, esqueça o link simbólico acima. Se você foi afobado e já criou antes de ler o post, então desfaça-o:

unlink /usr/src/linux

Então entre no diretório /usr/src e copie o kernel e o firmware:

cd /usr/src
git clone https://github.com/raspberrypi/linux.git
git clone https://github.com/raspberrypi/firmware.git

O procedimento para essa última opção é diferente, então vamos iniciar o processo por ela.

Compilando módulos a partir dos fontes do git

Após baixados os ítens anteriormente citados, siga com o seguintes comandos após entrar no diretório linux:

make mrproper
make bcmrpi_defconfig
make modules_prepare
cp ../firmware/extra/Module.symvers .

O comando bcmrpi_defconfig cria um .config, portanto você não precisará se preocupar com isso.

Faça o link para o caminho dos módulos:

sudo ln -s /usr/src/linux /lib/modules/$(uname -r)/build
sudo ln -s /usr/src/linux/arch/arm /usr/src/linux/arch/armv6l

Do mesmo modo, entre em /usr/src/linux e pule para o texto em "Make menuconfig".

Usar versão do kernel via apt-get

Fiz também o teste baixando uma versão default do respositório que é diferente da versão do kernel no meu sistema:

apt-get install linux-source-3.18
cd /usr/src/linux
tar xvJf linux-source-3.18.tar.xz 
ln -s linux-source-3.18 linux
cd linux
make menuconfig

Agora vá ao subtítulo mais abaixo onde está escrito "Make menuconfig" e continue de lá.

Arquivo de configuração do kernel

Algumas distribuições Linux mantém o arquivo de configuração do kernel em utilização dentro de /boot. Dê uma olhada se tem algo como /boot/kernelconfig-* no seu sistema. Se tiver, copie-o para a raiz dos fontes do kernel que você acabou de instalar, já com o nome necessário:

sudo cp /boot/kernelconfig* /usr/src/linux/.config

Se você instalou o kernel pelo apt, dentro de /usr/src você encontrará também um diretório linux-config-$VERSAO_DO_KERNEL. Dentro desse diretório tem os arquivos .config com as configurações para cada plataforma:

Nessa imagem você pode notar que já descomprimi o arquivo de configuração do RPi2. Basta decomprimí-lo e copiá-lo como /usr/src/linux/.config . Daí siga para o próximo passo.

Make menuconfig

Se você não tiver o kernelconfig e vai mesmo só compilar um módulo, sem problemas. Apenas siga o processo:

make menuconfig

Abrir-se-á esse menu. Perceba que estou sobre a opção "save". Para mudar os botões vá apertando [Tab]. Você deverá salvá-lo posteriormente com o nome padrão ".config". Esse ponto na frente o torna um arquivo oculto dentro do diretório raiz do kernel e é por esse arquivo que o make procura na hora da compilação.

O próximo passo é ativar a carga de módulos, porque se você baixou do kernel.org esse suporte não estará ativo por padrão.

Confesso que não sei se é fundamental, mas eu preferi garantir múltiplas arquiteturas. Entre no menu

Por fim, em "File systems" habilite XFS como módulo, apertando a barra de espaço sobre ele uma vez. Deverá aparecer a letra "". Feito isso, salve e saia desse menu. Agora basta compilar o suporte:

cd /usr/src/linux && make fs/xfs/xfs.ko

Se tudo der certo, você deve ver isso no final da compilação:

Ou ainda, você pode opcionalmente utilizar outro comando:

make modules  SUBDIRS=fs/xfs

Para instalar o módulo (sendo a mesma versão do kernel que você tem), digite:

make modules_install

Se compilou uma versão diferente do kernel nativo e quer tentar fazer load desse driver, você pode (por conta e risco) tentar fazer a cópia do driver para o respectivo diretório do kernel de onde os módulos são carregados:

cp /usr/src/linux/fs/xfs/xfs.ko /lib/modules/4.1.17+/kernel/fs/xfs/

Depois para carregar:

modprobe --force xfs

Se a carga for feita corretamente, você encontrará o módulo assim:

lsmod|grep xfs

Kernel oDroid

Adicionalmente aos pacotes citados no início deste artigo adicione o git e libqt4, então faça o clone de um dos níveis do kernel do oDroid. Por exemplo:

git clone --depth 1 https://github.com/hardkernel/linux.git -b odroidxu3-3.10.y odroidxu3-3.10.y 
cd odroidxu3-3.10.y 
make odroidxu3_defconfig 
make menuconfig

E no menu, siga o processo descrito posteriormente. O processo para compilar apenas o módulo é exatamente o mesmo, mas se quiser ter um trabalho monstruoso, você pode fazer o make dividindo a tarefa pelo número de processadores desejado:

make -j 4

Pra finalizar, instale o xfsprogs.

Se acontecer de me dar vontade, devo mostrar a compilação de um kernel completo, mas aí faz cross-comp porque se for fazer direto no RPi, vai dias provavelmente.

Inscreva-se no nosso canal Manual do Maker Brasil no YouTube.

Próximo post a caminho!