Tutorial do driver de dispositivo Linux para iniciantes

O sistema operacional Linux contém 3 seções principais: sistema de arquivos raiz, kernel e bootloader.

Sistema de arquivos raiz:

Esta parte do sistema operacional contém binários de aplicativos, bibliotecas, scripts, arquivos de configuração e arquivos de módulo carregável de kernel etc.…

Núcleo:

Esta parte é o coração do sistema operacional, o kernel é responsável por lidar com todas as operações necessárias para executar o sistema operacional, como gerenciamento de memória, gerenciamento de processos e operações de hardware de entrada/saída etc

Bootloader:

Esta é a primeira parte a ser executada pela CPU na inicialização. O BootLoader contém o código -fonte para inicializar o sistema e iniciar executar o kernel e contém comandos para depuração e modificação do ambiente do kernel, ele também contém os comandos para baixar e atualizar as imagens do kernel e do sistema na memória flash.

Os motoristas atuam como uma ponte entre hardware e um aplicativo de usuário, o kernel fornece um mecanismo chamado Sistema de Sistema para falar com o kernel. No Linux, os drivers podem ser implementados de duas maneiras, um dos motoristas pode ser compilado como parte do kernel e outro é que os motoristas podem ser compilados como módulos e carregados em tempo de execução.

Vamos começar com um simples módulo Hello World Kernel. Aqui está o código -fonte para um simples módulo Hello World Kernel.

olá.c

#include // necessário para Module_init e Module_exit
#include // necessário para kern_info
#include // necessário para as macros
int __init hw_init (void)
printk (kern_info "Hello World \ n");
retornar 0;

void __exit hw_exit (void)
printk (kern_info "Bye World \ n");

Module_license ("GPL");
module_init (hw_init);
module_exit (hw_exit);

Makefile

obj-m: = olá.o
todos:
make -c/lib/módulos/$ (shell uname -r)/build m = $ (pwd) módulos
limpar:
make -c/lib/módulos/$ (shell uname -r)/build m = $ (pwd) limpo

Crie uma pasta chamada olá E então coloque o olá.c e Makefile dentro dele. Abra o terminal Diretório de aplicação e alteração para olá. Agora execute o comando fazer e se for bem -sucedido, deve gerar arquivo de módulo de kernel carregado chamado olá.Ko.

Quando você corre, se você tiver saída make: nada a ser feito para 'tudo'. Em seguida, verifique se no makefile você entrou na guia (sem espaços) antes de fazer -c. Se a marca for bem -sucedida, você deve obter a saída como mostrado abaixo.

Faça [1]: Inserir diretório '/usr/src/linux-headers-3.13.0-128 Generic '
CC [M]/Home/John/Desktop/Hello/Hello.o
Módulos de construção, estágio 2.
Módulos MODPOST 1
CC/Home/John/Desktop/Hello/Hello.mod.o
LD [M]/Home/John/Desktop/MVs/Pers/Kern/Hello/Hello.Ko
Faça [1]: Deixando o Diretório '/usr/src/linux-headers-3.13.0-128 Generic '

Agora vamos testar o módulo carregando -o no kernel. Para carregar e descarregar módulos do kernel, precisamos ter permissão de superusuário. Use o seguinte comando para carregar o módulo do kernel no kernel.

sudo insmod olá.Ko

Para ver a mensagem Printk, você precisa verificar o log do kernel, para verificar o log do kernel, use o seguinte comando.

DMESG

Este comando produzirá as mensagens de log do kernel, no final você deve ver que nossa mensagem Olá Mundo impresso.

Para descarregar o módulo, use o seguinte comando.

sudo rmmod olá

Para ver a mensagem Printk, use o comando dmesg novamente e no log do kernel, você pode ver nossa mensagem Tchau mundo.

Agora vamos entender o código -fonte.

olá.c

Para começar a escrever o motorista do kernel, você pode usar qualquer editor ou IDE de sua escolha, mas os desenvolvedores mais comumente preferem usar vi editor.

Cada módulo de kernel deve incluir o arquivo de cabeçalho Linux/Module.h Isso tem as declarações e macros para funções do kernel, como Module_init e Module_exit etc. As duas funções mais necessárias para um driver de kernel são as funções Module_init e Module_exit. A função cujo ponteiro é passado para Module_init será executado quando carregarmos o módulo no kernel, e a função cujo ponteiro é passado para Module_exit será chamado quando descarregarmos ou remover o módulo do kernel.

Dentro do kernel para depuração e impressão do tronco, usamos printk função que é semelhante à função PrintF que usamos no aplicativo. Você pode usar as macros como Kern_info, Kern_err etc ... para especificar um nível de log.

Se estamos escrevendo um motorista para conversar com um hardware específico, a função init deve ter o código para inicializar o hardware antes de começarmos a usá -lo e a função de saída deve ter um código para limpar os recursos (memória dinâmica etc.) que usamos no driver antes de sairmos do kernel.

Aqui neste exemplo, estamos apenas imprimindo mensagens de depuração nas funções init e de saída.

Makefile

Para a construção do módulo do kernel, precisamos escrever um makefile que guiará fazer utilidade como compilar o módulo. A sintaxe obj-m é usado para dizer ao kernel makefile que o motorista precisa ser compilado como módulo usando o arquivo de objeto especificado. Quando você apenas executa o comando fazer Então o controle chega ao todos: seção do makefile e se você executar comando Faça limpo Então o controle vai para o limpar: Seção do Makefile. A partir deste makefile, estamos realmente executando, faça dentro do diretório de origem do kernel usando a opção -C. Certifique -se de ter o diretório de origem do kernel instalado em seu sistema. Aqui neste exemplo, usamos comando uname -r Para encontrar a versão atual do kernel Linux do seu sistema.

Usamos a opção M = $ (PWD) para indicar no kernel makefile que a fonte do driver está no diretório de trabalho atual e estamos especificando a palavra módulos Para dizer ao kernel makefile para construir módulos e não construir o código -fonte completo do kernel. Em limpar: Seção do Makefile, estamos dizendo ao kernel makefile para limpar os arquivos de objeto gerados para construir este módulo.

Isso deve começar a compilar e executar seu primeiro módulo de kernel.