Kernel Linux Programação Parte 1

Introdu¸cão Montando o ambiente Criando módulos Gerenciamento de Memória Estruturas de Dados
Programa¸cão para o Kernel Linux (Parte 1)
Ivo Augusto Andrade Rocha Calado
Instituto Federal de Educa¸cão, Ciência e Tecnologia de Alagoas
29 de Junho de 2014
1 / 96 Ivo Calado IFAL

Sobre o palestrante
Titula¸cão:
Graduado em Ciência da Computa¸cão pela UFAL
Mestre em Ciência da Computa¸cão pela UFCG
Doutorando em Engenharia Elétrica pela UFCG
Email:
ivo.calado@ee.ufcg.edu.br
ivo.calado@ifal.edu.br ou
Site:
https://sites.google.com/a/ee.ufcg.edu.br/ivocalado/

Experiˆencia com o Linux
Contato com Linux desde 2004
Utiliza o Linux como principal SO desde 2006
Contribui com o Kernel Linux a partir do desenvolvimento de
algoritmos de controle de congestionamento no protocolo
DCCP
CCID-4 e CCID-5 (DCCP Cubic)

E sobre vocês?...
Qual a experiência com sistemas operacionais?
... E com o Linux? Apenas usuário doméstico ou um pouco
mais?
Quem já fu¸cou e/ou compilou o kernel?
Qual o conhecimento sobre a linguagem de programa¸cão C,
Redes de Computadores, Estruturas de Dados e Sistemas
Operacionais

Objetivo do curso
Mostrar o que é e como o Kernel Linux está organizado
Apresentar uma visão geral sobre a programa¸cão para o
Kernel Linux
Quais as etapas necessárias para para implementa¸cão de
módulos?
Que ferramentas auxiliam no processo de cria¸cão e submissão
de patches?

Agenda I
1 Introdu¸cão
O que é um sistema operacional?
Linux
Caracter´ısticas do Kernel Linux
Diferen¸cas entre desenvolvimento para Kernel e User space
2 Montando o ambiente
Obtendo e Compilando o Kernel Linux
A Ferramenta de Gerência de Código Git
Criando e aplicando patches com o Git
3 Criando módulos
O módulo Hello World
Um pouco mais sobre módulos

Agenda II
4 Gerenciamento de Mem´oria
kmalloc
slab cache
5 Estruturas de Dados
Conceitos
Linked list

Observa¸c˜ao sobre este material
Este material ´e derivado de diversos trabalhos livremente
dispon´ıveis na Internet

O que viria a ser um sistema operacional?
Uma m´aquina estendida?
Um gerenciador de recursos?

O que viria a ser um sistema operacional?
Uma máquina estendida?
Um gerenciador de recursos?
Ambos!
Atribui¸cões de um SO
Gerenciamento de processos
Gerenciamento de memória
Gerenciamento de dispositivos
Sistemas de arquivos
Entrada e sa´ıda de dados

Arquitetura de um sistema operacional

Arquitetura de um sistema operacional
Dois espa¸cos de endere¸camento
Espa¸co de Usuário (User-space)
Espa¸co de Kernel (Kernel-space)
Três componentes básicos
System calls: engloba um conjunto de fun¸cões
disponibilizadas pelo sistema operacional para prover servi¸cos
Núcleo: engloba mecanismos responsáveis pelas gerência de
memória, processos, sistemas de arquivos, abstra¸cões de
acesso a hardware etc
Device Drivers: fornecem implementa¸cões que proporcionam
acesso a diversos mecanismos de hardware

Linux
GNU, Linux ou GNU/Linux
Qual a diferen¸ca entre Linux e GNU/Linux?

Linux
Linux: n´ucleo do SO (e para alguns considerado o “SO”)
Ferramentas GNU: conjunto de ferramentas como
compiladores, editores de texto, linguagem bash etc

Linux
Linux: núcleo do SO (e para alguns considerado o “SO”)
Ferramentas GNU: conjunto de ferramentas como
compiladores, editores de texto, linguagem bash etc
A controvérsia sobre o nome
Existe uma grande controvérsia sobre o nome correto do SO. Um
grupo de usuários, em especial desenvolvedores GNU, afirmam que
o nome correto é GNU/Linux. Por outro lado, outro grupo
encabe¸cado por Linus Torvalds preferem simplesmente Linux
Em termos práticos, do ponto de vista de um usuário o SO ==
GNU + Linux

Linux
Versionamento
Durante muito tempo foi utilizado a nota¸c˜ao baseada em 3
n´umeros + 1 adicional
Segundo um dos mantenedores do Linux, Willy Tarreau, “The
4-integer numbering was a real nightmare with kernel versions
looking like IP addresses. Now it will get back to something more
common and much more maintainable.”

Linux
Versionamento
Em vista da situa¸cão apresentada, e também para comemorar
os 20 anos do Linux, Linus Torvalds decidiu alterar a forma
como as versões definidas
3.0, 3.1.1, 3.2-rc1, ...
Agora são 2 números + 1
Porém, em termos práticos a versão 2.6.40 == 3.0

Kernels monol´ıticos x Micro Kernels
O desenvolvimento de sistemas operacionais é marcado por
duas escolas que são
Kernels Monol´ıticos
Micro Kernels
(a) Micro Kernel (b) Kernel Monol´ıtico: único espa¸co de
endere¸camento

Micro Kernels
Possui como mais conhecido defensor Andrew Tanenbaum
Implementado como vários processos
Diferentes binários e espa¸cos de endere¸camento.
Comunica¸cão via IPC (lento)
Faz uso extensivo do conceito de servidores, onde apenas
poucos servi¸cos devem rodar em modo privilegiado
Desvantagens: teoricamente robusto porém complexo de se
desenvolver
Exemplos: Minix e Symbian

Kernels Monol´ıticos
Único espa¸co de endere¸camento
Único processo executante
Mais fácil de implementar, comunica¸cão rápida e facilidade de
utiliza¸cão (fun¸cões são globais)
Desvantagem: Mais suscet´ıvel a crashes
Exemplos: BSD, Windows, Linux*

Linux: Monol´ıtico mas modular
O Linux é considerado um Kernel monol´ıtico. Porém ele
implementa diversas ideias do mundo “Micro Kernel”:
Projeto modular
Ser preempt´ıvel
Possibilita o carregamento de módulos binários dinamicamente
Ou seja, o projeto do Linux é baseado no melhor dos dois mundos

Diferente, não dif´ıcil
Muitas pessoas tem uma visão que o desenvolvimento para
Kernel Linux é bastante dif´ıcil
Todavia, grande parte dessa “dificuldade” reside no fato das
diferen¸cas existentes no modo de programa¸cão entre Kernel
space e User space
Algumas diferen¸cas são óbvias (o kernel pode fazer qualquer
coisa! :))...

Diferente, não dif´ıcil
Muitas pessoas tem uma visão que o desenvolvimento para
Kernel Linux é bastante dif´ıcil
Todavia, grande parte dessa “dificuldade” reside no fato das
diferen¸cas existentes no modo de programa¸cão entre Kernel
space e User space
Algumas diferen¸cas são óbvias (o kernel pode fazer qualquer
coisa! :))... outras nem tão óbvias
Vamos ver algumas das principais diferen¸cas...

Libc e cabe¸calhos C padrão
A libc é a biblioteca padrão em user space
Ela fornece as implementa¸cão de grande parte das fun¸cões
dispon´ıveis
Porém ela não pode ser utilizada em kernel space por diversas
razões:
Velocidade
Tamanho
Problema do Ovo e da Galinha! :)
Quais as consequencias?
Fun¸cões como printf e scanf, malloc, calloc não estão dispon´ıveis

Libc e cabe¸calhos C padrão
Como discutido, o kernel não provê fun¸cões da libc, porém
algumas fun¸cões substitutas são disponibilizadas
As assinaturas de tais fun¸cões são armanezadas no diretório
include na árvore do kernel
A fun¸cão printk
A fun¸cão printk possibilita a impressão de uma mensagem na tela
printk(LOG LEVEL “Mensagem e formatadores!”, vars...);
KERN EMERG
KERN ALERT
KERN INFO
...

Sem prote¸cão de memória
O que acontece quando, em n´ıvel de aplica¸cão tentamos acessar
uma área inválida de memória (ex.: deferenciar um ponteiro nulo)?

O tão famoso segmentation fault!
Em termos técnicos, o kernel captura o acesso indevido e
lan¸ca um sinal SIGSEGV mantando o processo
Porém voltamos para o problema do ovo e da galinha. Isso seria
poss´ıvel de ser feito no kernel?

Quais as consequencias de um acesso inv´alido de mem´oria?
No melhor dos casos um kernel panic.

Quais as consequencias de um acesso inv´alido de mem´oria?
No melhor dos casos um kernel panic. No pior uma brecha de
seguran¸ca!

Memória sem pagina¸cão
Memória virtual e pagina¸cão é um poderoso recurso de
gerência de memória
Possibilita que aplica¸cões fa¸cam uso de mais memória que a
memória f´ısica dispon´ıvel alocando as “páginas” mais
acessadas na memória principal e mandando o restante para o
disco
Se esse conceito também valer para o Kernel, o que acontece se o
bloco de memória contendo instru¸cões que efetuam a gerência de
memória for “por acaso” enviado para o disco???

Memória sem pagina¸cão
Memória virtual e pagina¸cão é um poderoso recurso de
gerência de memória
Possibilita que aplica¸cões fa¸cam uso de mais memória que a
memória f´ısica dispon´ıvel alocando as “páginas” mais
acessadas na memória principal e mandando o restante para o
disco
Se esse conceito também valer para o Kernel, o que acontece se o
bloco de memória contendo instru¸cões que efetuam a gerência de
memória for “por acaso” enviado para o disco???
Qual a solu¸cão?
Manter todo o bloco de memória do Kernel alocado em memória
fisica! Sendo assim, cada byte de memória no Kernel é precioso!

Obtendo o Kernel Linux

Obtendo e compilando o Kernel Linux
Existem basicamente duas formas de se obter o Kernel Linux:
Baixando um tarball da última versão do kernel dispon´ıvel em
kernel.org ou via pacotes de distribui¸cões
Baixando uma versão de desenvolvimento via git

Baixando os pacotes básicos
Após a instala¸cão de uma versão limpa do Ubuntu, diversos
pacotes são necessários antes da compila¸cão propriamente dita
apt−get i n s t a l l build −e s s e n t i a l l i b g t k 2 .0−dev l i b g l i b 2
.0−dev l i b g l a d e 2 −dev l i b n c u r s e s 5 −dev
Após a instala¸cão dos pacotes básicos necessários à compila¸cão,
devemos obter e compilar o kernel propriamente dito. Para tal,
podemos seguir a op¸cão Linux-like ou Ubuntu-like

Baixando e configurando o kernel (Linux-like)
Para obter o kernel Linux mais atual basta baixá-lo de
https://www.kernel.org/.
Após o download, podemos configurá-lo de 3 maneiras
distintas:
make menuconfig
make c o n f i g
meke g c o n f i g
Também é poss´ıvel carregar configura¸cões antigas via make
oldconfig

Menu de conﬁgura¸c˜ao
Vamos fu¸car um pouco... :)

Compilando o kernel (Linux-like)
Para construir o kernel, basta executar o seguinte comando
make [− jn ]
sudo make m o d u l e s i n s t a l l
O primeiro comando irá salvar um arquivo bzImage em
arch/[arquitetura]/boot
O segundo comando irá salvar os módulos gerados em
/lib/modules
Após isso, devemos manualmente configurar o gerenciador de Boot
(lilo ou grub) para carregar a nova imagem!

Baixando e instalando o kernel (Ubuntu-like)
O Ubuntu (assim como outras distribui¸cões) oferece uma maneira
própria de baixar, compilar e instalar um kernel
Após a instala¸cão de uma versão limpa do Ubuntu, diversos
pacotes são necessários antes da compila¸cão propriamente dita
apt−get i n s t a l l l i n u x −source −3.13.0 kernel −package
f a k e r o o t
Após a instala¸cão, deve ser descompactado e criado um link
ligando o diretório do kernel para /usr/src/linux
t a r −xvf l i n u x −source −3.13.0. t a r . bz2
l n −s l i n u x −source −3.13.0 / usr / s r c / l i n u x

Reutilizando arquivo de configura¸cão
A próxima etapa é a cópia do arquivo de configura¸cão para o
diretório base do kernel
% cp / boot / config −‘uname −r ‘ / usr / s r c / l i n u x /. c o n f i g
Por fim, deve-se entrar no diretório do código do kernel e
executar o menu para visualiza¸cão das op¸cões

Compila¸cão :)
Limpar diretório antes da compila¸cão
make−kpkg clean
Compilando
f a k e r o o t make−kpkg −−i n i t r d −−append−to−v e r s i o n=−
custom k e r n el i m ag e k e r n e l h e a d e r s
Caso fosse realizada a compila¸cão genérica só seria necessário a
execu¸cão do comando make

Instalando
Por ﬁm, basta instalar os arquivos *.deb que foram
armazenados na pasta /usr/src
dpkg −i ∗. deb
Esse comando realiza as seguintes tarefas
Instala a imagem
Instala os headers do kernel
Conﬁgura o grub para dual-boot

A estrutura de diretórios do kernel
Composta por 5 blocos
Includes
Documenta¸cão
Scripts
Exemplos (samples)
Implementa¸cões (net, arch, init, block, crypt etc)

Controle de Vers˜ao Git

Trata-se de um sistema de controle de versão distribu´ıdo
O Git foi inicialmente projetado e desenvolvido por Linus
Torvalds para o desenvolvimento do núcleo do Linux, porém
atualmente ele é amplamente utilizado para os mais diversos
propósitos
Não há a ideia de repositório central como no CVS ou SVN
mas sim diversas árvores distribu´ıdas onde uma elas podem
fazer push e pull uma das outras
Ideal para montarmos um repositório local sem a necessidade
de instala¸cão (a cria¸cão de um repositório leva apenas 1
comando!)

Foco na cria¸cão de branches, realiza¸cão de merges e gera¸cão
de diffs entre diferentes pontos da árvore

Instalando e conﬁgurando o git
apt−get i n s t a l l g i t
g i t c o n f i g −−g l o b a l user . name "Nome"
g i t c o n f i g −−g l o b a l user . email "email@dominio.com"

Criando nosso primeiro repositório
Para cria¸cão de um repositório precisamos de apenas um comando!
:)
$ mkdir repo
$ cd repo
$ g i t i n i t .
Após a inicializa¸cão do repositório precisamos apenas adicionar os
arquivos via o comando git add
g i t add f i l e 1 [ f i l e 2 ] [ f i l e 3 ] [ f i l e 4 ] . . .
g i t commit −a

branches, diffs, checkouts, merges, stashes, logs...
g i t branch # l i s t a branches
g i t branch nome # c r i a uma branch
g i t checkout nome da branch # a l t e r n a e n t r e branches
g i t d i f f # l i s t a a d i f e r e n ¸c a s a d i c i o n a d a s e a d i f e r e n ¸c a
e n t r e d o i s pontos do r e p o s i t ó r i o
g i t merge # a t u a l i z a uma branch com base em outras
g i t r e s e t −−hard HEADˆ # remove o último commit
g i t log # l i s t a todos os commits r e a l i z a d o s
g i t a r c h i v e −−format t a r . gz −−output arquivo . t a r . gz
branch name −v
g i t rm f i l e # remove um arquivo da á r v o r e
g i t mv f i l e # renomeia um arquivo da á r v o r e
Vamos praticar um pouco!? Inicializem um projeto e realizem
diversas altera¸cões fazendo uso das op¸cões dispon´ıveis acima

Clonando uma árvore git
Até agora, vimos como criar, modificar e manipular o
repositório de diversas maneiras
Porém, como obtemos um código de outra pessoa?
Devemos fazer uso do comando git clone
g i t clone g i t :// eden−feed . erg . abdn . ac . uk/ dccp exp
my dccp

Criando patches com o Git
Após criarmos fazermos nossas modifica¸cões chegou a hora de
gerarmos o patch para submissão
Para isso fazemos uso do comando git format-patch
g i t format−patch [ o b j e c t i d ou branch name ] −−stdout >
p . patch
g i t format−patch [ o b j e c t i d ou branch name ]
g i t format−patch −s [ o b j e c t i d ou branch name ]
O primeiro comando irá gerar uma única sa´ıda enquanto que o
segundo cria vários arquivos de sa´ıda (um para cada commit)

Checando os patches com checkpatch.pl
Após criamos nossos patches temos de verificar se eles estão
dentro do estilo de código adotado no kernel linux (80 colunas,
sem espa¸cos antes do tab, sem espa¸cos no final da linha etc)
s c r i p t s / checkpatch . p l [ arquivo . patch ]
Este comando irá listar todos os problemas de estilo existentes
no código
Antes de ser submetido todos os problemas devem ser
resolvidos

Estrutura do patch
O patch gerado é dividida em 5 partes distintas:
Cabe¸calho do email
Descri¸cão do patch
Assinaturas
Sumário das altera¸cões
Patch propriamente dito

Assinaturas
A assinatura tem por objetivo possibilitar um rastreio da
autoria das altera¸cões realizadas
Em geral, o código é revisto por diversos desenvolvedores até
chegar na árvore do kernel
Também serve como uma declara¸cão, por parte do autor, de
que está disponibilizando o código como open-source
Uma forma de eternizar o autor! :)
Signed-off-by: Autor 1 <random@developer.example.org>
Outras entradas poss´ıveis: Ack-by e Cc, Reported-by e
Tested-by

Curiosidade: porque utilizar o signoff?
Em meados de 2003, uma empresa chamada SCO come¸cou a
questionar a autoria de diversos códigos do kernel Linux em virtude
dela possuir contratos com a IBM que na época fez a doa¸cão de
códigos para open source. A empresa afirmava que trechos de
código do Unix V estavam incorporados ao Linux.
Foram iniciados uma série de processos envolvendo a SCO e
diversas empresas como: IBM, Red Hat, Novell etc. onde foi
comprovado que a SCO estava errada! :)
http://en.wikipedia.org/wiki/Timeline_of_SCO-Linux_
controversies

Último teste antes do envio
Antes de realizar o envio do patch é recomendável tentar
aplicar o patch em uma árvore limpa de modo a verificar se
algum erro inesperado irá acontecer
A ideia é tentar reproduzir o procedimento de quem irá aplicar
o patch à arvore
g i t apply −−s t a t ∗. patch # Sumário de m o d i f ic a ¸cõe s
g i t apply −−check ∗. patch # Checagem por e r r o s
g i t am −−s i g n o f f ∗. patch # Aplica¸cão do patch

Envio de patches: Para quem? de que maneira?
O envio de patches do kernel do Linux é realizado através de
emails para listas de discussões espec´ıficas
Existem diversas listas dispon´ıveis em vger.kernel.org:
alsa-devel, autofs, ceph-devel, dccp, netdev etc. Escolha
a correspondente e a lista com um n´ıvel acima
ex.: dccp e netdev
Regras básicas: email sem formata¸cão e sem anexos! O
código irá no corpo do email

Envio de patches: Para quem? de que maneira?
O envio de patches do kernel do Linux é realizado através de
emails para listas de discussões espec´ıficas
Existem diversas listas dispon´ıveis em vger.kernel.org:
alsa-devel, autofs, ceph-devel, dccp, netdev etc. Escolha
a correspondente e a lista com um n´ıvel acima
ex.: dccp e netdev
Regras básicas: email sem formata¸cão e sem anexos! O
código irá no corpo do email
Dica final: se poss´ıvel, envie o patch para que outras pessoas dar
uma olhada antes do envio propriamente dito!

Atividade: gerenciando o código com git
O objetivo desta atividade é a prática da gerência de código
utilizando o git
Configure as propriedades de usuário e email
Iniciar um repositório na árvore do kernel
Adicionar os arquivos no repositório e realizar primeiro commit
Criar uma branch com nome “teste” e realizar alguns commit
com diferentes modifica¸cões
Verificar a diferen¸ca entre o branch atual e a master
Voltar para a branch master e realizar um merge das
modifica¸cões
Preparar um patch de envio
Tempo da atividade: 15 - 20 minutos

Criando m´odulos para o Kernel

Configurando ambiente de teste
Finalmente chegou a hora de rodarmos o nosso primeiro
módulo
O mais simples dos módulos deve oferecer duas
funcionalidades básicas: Carregamente e descarregamento
do módulo

#i n c l u d e <l i n u x / i n i t . h>
#i n c l u d e <l i n u x /module . h>
MODULE LICENSE( "GPL" ) ;
s t a t i c i n t h e l l o i n i t ( void )
{
p r i n t k (KERN ALERT "Hello , worldn" ) ;
r e t u r n 0;
}
s t a t i c void h e l l o e x i t ( void )
{
p r i n t k (KERN ALERT "Goodbye , cruel worldn" ) ;
}
m o d u l e i n i t ( h e l l o i n i t ) ;
module exit ( h e l l o e x i t ) ;

As macros module init e module exit são responsáveis por
indicar quais fun¸cões irão carregar e descarregar o módulo
No exemplo apresentado, o módulo exibe apenas uma
mensagem na abertura e no descarregamento do módulo!

Compilando
A forma de compilar módulos do Kernel é um pouco diferente
da compila¸cão normal de uma aplica¸cão C
O primeiro passo é contruir o arquivo Makefile
Nosso arquivo Makefile
obj−m := h e l l o . o
ou
obj−m := module . o
module−o b js := f i l e 1 . o f i l e 2 . o
Compila¸cão: make -C /usr/src/linux M=‘pwd‘ modules

Executando
Inser¸c˜ao, remo¸c˜ao, listagem...
insmod h e l l o . ko # I n s e r e modulo
lsmod # L i s t a modulos
rmmod h e l l o # Remove modulo

Executando
Inser¸cão, remo¸cão, listagem...
insmod h e l l o . ko # I n s e r e modulo
lsmod # L i s t a modulos
rmmod h e l l o # Remove modulo
Onde são exibidas as mensagens provenientes do Kernel?
Mensagens impressas via fun¸cão printk tem dois direcionamentos
/var/log/syslog
dmesg

Entendendo o funcionamento de um módulo
Fun¸cões init e exit servem apenas para aloca¸cão de recursos
e registro de servi¸cos através de callbacks. Um bom
exemplo é o registro de novos protocolos de transporte
Módulos apenas provem servi¸cos. Não são entidades ativas!
Por ser um núcleo preempt´ıvel o módulo deve suportar
concorrência (race conditions)

Adicionando o módulo como uma nova op¸cão
Para adicionar o módulo no menuconfig deve-se adicionar à árvore
do kernel e editar arquivos Makefile e Kconfig (tanto do módulo
quanto do n´ıvel acima)
Kconfig :
c o n f i g HELLO BUILDTIN EXAMPLE
t r i s t a t e "Modulo exemplo Hello World"
depends on INET
−−−help−−−
Este modulo tem o b j e t i v o puramente e x p e r i m e n t a l
Makefile :
obj−$ (CONFIG HELLO BUILDTIN EXAMPLE) := h e l l o b u i l t i n
. o

Como funcionam as callbacks em C?
Em C, o endere¸co de uma fun¸cão é acess´ıvel ao programador
através de uma variável do tipo ponteiro para fun¸cão
A partir desse mecanismos torna-se poss´ıvel abstrair qual
implementa¸cão será executada de maneira semelhante a
polimorfismo

Como funcionam as callbacks em C?
Em C, o endere¸co de uma fun¸cão é acess´ıvel ao programador
através de uma variável do tipo ponteiro para fun¸cão
A partir desse mecanismos torna-se poss´ıvel abstrair qual
implementa¸cão será executada de maneira semelhante a
polimorfismo
s t r u c t opr {
i n t value1 ;
i n t value2 ;
i n t (∗ o p e r a t i o n ) ( int , i n t ) ;
};

A tabela de s´ımbolos do Kernel
Todo módulo ao ser desenvolvido tem acesso a um conjunto
de s´ımbolos disponibilizados pelo Kernel
S´ımbolos podem ser tanto variáveis quanto fun¸cões (ex.: a
fun¸cão printk)
Analogia a s´ımbolos exportados de uma lib dinâmica
Um problema comum é a tentativa de utiliza¸cão de s´ımbolos
não definidos/não vis´ıveis
Como exportar s´ımbolos de um módulo?
EXPORT SYMBOL(name) ;
EXPORT SYMBOL GPL(name) ;

A tabela de s´ımbolos do Kernel
Todo módulo ao ser desenvolvido tem acesso a um conjunto
de s´ımbolos disponibilizados pelo Kernel
S´ımbolos podem ser tanto variáveis quanto fun¸cões (ex.: a
fun¸cão printk)
Analogia a s´ımbolos exportados de uma lib dinâmica
Um problema comum é a tentativa de utiliza¸cão de s´ımbolos
não definidos/não vis´ıveis
Como exportar s´ımbolos de um módulo?
EXPORT SYMBOL(name) ;
EXPORT SYMBOL GPL(name) ;
EXPORT SYMBOL GPL limita a exporta¸cão à GPL

Licensiamento de módulos
Módulos podem ser registrados sob diferentes licensas utilizando a
macro MODULE LICENSE:
GPL
GPL v2
GPL and additional rights
Dual BSD/GPL
Dual MPL/GPL
Proprietary
Um módulo é considerado proprietário até segunda ordem

Manipula¸cão de erros durante a inicializa¸cão
A fun¸cão init serve para aquisi¸cão de recursos do módulo
(memória, locks em dispositivos, registros de protocolos etc)
Porém o que acontece se um dos recursos não pode ser
obtido?

A fun¸cão init serve para aquisi¸cão de recursos do módulo
(memória, locks em dispositivos, registros de protocolos etc)
Porém o que acontece se um dos recursos não pode ser
obtido?
Duas op¸cões
Continuar a execu¸cão com funcionalidades reduzidas
Cancelar a inicializa¸cão do módulo
Neste sentido, qual seria a abordagem mais adequada para fazer
essa manipula¸cão de erros?

Qual seria uma solu¸cão elegante para a libera¸cão de recursos já
alocados?

Qual seria uma solu¸cão elegante para a libera¸cão de recursos já
alocados?
i n t i n i t minha funcao ( void )
{
i n t e r r ;
/∗ r e g i s t r a t i o n takes a p o i n t e r and a name ∗/
e r r = r e g i s t e r t h i s ( ptr1 , "skull" ) ;
i f ( e r r ) goto f a i l t h i s ;
e r r = r e g i s t e r t h a t ( ptr2 , "skull" ) ;
i f ( e r r ) goto f a i l t h a t ;
r e t u r n 0; /∗ s u c c e s s ∗/
f a i l t h a t : u n r e g i s t e r t h i s ( ptr1 , "skull" ) ;
f a i l t h i s : r e t u r n e r r ; /∗ propagate the e r r o r ∗/
}

Parâmetro de inicializa¸cão
Muitas vezes precisamos passas configura¸cões espec´ıficas ao
módulo que vai ser inicializado
Exemplos:
Ativa¸cão ou desativa¸cão do debug
Configura¸cões espec´ıficas de protocolos
Configurões de módulos de dispositivos etc
Para esta tarefas duas fun¸cões estão associadas: module param
(ou module param array) e MODULE PARM DESC

Adicionando parâmetros de inicializa¸cão
Sintaxe: module param(parametro, tipo, permissao)
s t a t i c char ∗whom = "world" ;
s t a t i c i n t howmany = 1;
module param (howmany , int , S IRUGO) ;
module param (whom, charp , S IRUGO | S IWUSR) ;
module param array ( vetor , int ,& v e t o r s i z e , S IRUGO |
S IWUSR) ;
Parâmetro: variável a ser utilizada (deve ser static)
Tipo: Tipo da variável a ser exportada (bool, charp, int,
long, short etc)
Caso seja informado um número maior de valores do que o
tamanho do vetor é lan¸cado um erro e a inicializa¸cão do módulo é
abortada

Permissões dos módulos
O terceiro parâmetro tem por objetivo definir como o valor
exportado será vis´ıvel após a inicializa¸cão
Os valores dos parâmetros serão disponibilizados em
/sys/module/<nome modulo>/parameters
Cada parâmetro será armazenado em um arquivo espec´ıficos
É poss´ıvel definir todas as permissões poss´ıveis para um
arquivo

Permiss˜oes poss´ıveis
#d e f i n e S IRWXU 00700
#d e f i n e S IRUSR 00400
#d e f i n e S IWUSR 00200
#d e f i n e S IXUSR 00100
#d e f i n e S IRWXG 00070
#d e f i n e S IRGRP 00040
#d e f i n e S IWGRP 00020
#d e f i n e S IXGRP 00010
#d e f i n e S IRWXO 00007
#d e f i n e S IROTH 00004
#d e f i n e S IWOTH 00002
#d e f i n e S IXOTH 00001

Atividade: Criando módulos simples
Com base no apresentado vamos criar a seguinte escrutura de
módulos:
Criar 3 módulos chamados mod1, mod2, mod3 com seus
respectivos arquivos Makefile
Deve ser criada uma dependência de s´ımbolos (variáveis e
fun¸cões) entre os módulos (mod1 => mod2 => mod3)
Devem ser adicionados parâmetros para carregamento dos
módulos que incluam tanto valores editáveis, quanto somente
leitura. Além disso deve ser verificado a possibilidade de
escrita ou somente leitura
Deve ser avaliado tanto a exporta¸cão de s´ımbolos GPL para
módulos GPL quando para módulos não-GPL

Gerenciamento de memória no Kernel
Em user-space, estamos estamos habituados a três fun¸cões
básicas para gerenciamento de memória, que são malloc,
calloc e free
Todavia, tais fun¸cões fazem parte da libc e, portanto, não
estão dispon´ıveis
Vale lembrar que toda a memória do núcleo é armazenada em
memória f´ısica (sem memória virtual)
Deste modo, em n´ıvel de kernel as duas principais estratégias
para gerência da memória que são kmalloc e slab cache

kmalloc
kmalloc
Bastante semelhante a malloc e free
Possibilita a aloca¸cão de blocos de memória com base no
argumento size
Uma peculiaridade é o fornecimento de flags que serve para
controlar como o bloco de memória será alocado
#i n c l u d e <l i n u x / s l a b . h>
void ∗ kmalloc ( s i z e t s i z e , i n t f l a g s ) ;
k f r e e ( void ∗)

kmalloc
Sobre o parâmetro size
Em espa¸co de usuário a aloca¸cão é orientada à heap
(abstra¸cão de um bloco cont´ınuo)
Em espa¸co de núcleo, a aloca¸cão é orientada a páginas de
memória (memória segmentar)
kmalloc faz aloca¸cão blocos de páginas, ou seja, o tamanho
alocado pode ser ligeiramente MAIOR que o tamanho solicitado!

kmalloc
Sobre o parâmetro flag
Define como o bloco de memória será alocado levando em
considera¸cão as páginas de memórias atualmente dispon´ıveis
GFP ATOMIC: a aloca¸cão é realizada em alta prioridade
(como handlers de interrup¸cão) e a a¸cão não sofre preemp¸cão
GFP KERNEL: maneira padrão de aloca¸cão. A a¸cão é
preempt´ıvel
GFP USER: semelhante à GFP KERNEL porém alocado em
espa¸co de usuário.
Mais 13 tipos! Porém GFP ATOMIC e GFP KERNEL são
utilizadas em quase todos os casos de maneira segura

kmalloc
Modo de uso
s t r u c t my struct ∗ t = NULL;
t = ( s t r u c t my struct ) kmalloc ( s i z e o f ( s t r u c t my struc )
, GFP KERNEL) ;
i f ( ! t ) {
//N˜ao conseguiu a l o c a r . . .
}
//Uso . . .
k f r e e ( t ) ;// L i b e r a r e c u r s o

slab cache
slab cache
A abordagem utilizando kmalloc é voltada para cria¸cão de
objetos individuais
Porém, e se fossemos criar diversos objetos do mesmo tipo ao
longo do ciclo de vida de um módulo?...

slab cache
slab cache
objetos individuais
longo do ciclo de vida de um módulo?... ter´ıamos de nos
preocupar em configurar o tamanho para cada novo objeto
Exemplo: um objeto sk buff é criado todas as vezes que um
pacote de dados é recebido ou enviado
Qual seria uma poss´ıvel solu¸cão?

slab cache
slab cache
objetos individuais
longo do ciclo de vida de um módulo?... ter´ıamos de nos
preocupar em configurar o tamanho para cada novo objeto
Exemplo: um objeto sk buff é criado todas as vezes que um
pacote de dados é recebido ou enviado
Qual seria uma poss´ıvel solu¸cão?
Criar um procedimento que encapsule a cria¸cão de objetos
Para esta funcionalidade, o kernel provê o Slab

slab cache
Arquitetura Slab
Cria um pool de blocos de memória
Otimizado para criar objetos do mesmo tipo
São definidas quatro fun¸cões associadas à aloca¸cão/desaloca¸cão de
blocos de memória utilizando Slab
kmem cache create
kmem cache alloc
kmem cache free
kmem cache destroy

slab cache
Rotinas associadas

slab cache
A fun¸cão kmem cache create
kmem cache t ∗ kmem cache create ( const char ∗name ,
s i z e t s i z e ,
s i z e t o f f s e t , unsigned long f l a g s ,
void (∗ c o n s t r u c t o r ) ( void ∗) ;
name: Nome da estrutura (sem espa¸cos em branco)
offset: Deslocalmento desde o come¸co da página de memória.
Usado para alinhamentos espec´ıficos (normalmente zero)
flags: Controla como a aloca¸cão será realizada (normalmente
usa-se o valor SLAB HWCACHE ALIGN, pois irá alinhar a
memória seguindo a arquitetura da máquina)
constructor: utilizados para contru¸cão personalizada de
objetos complexos (é aceito NULL)

slab cache
Exemplo aloca¸c˜ao via slab
s t r u c t my struct ∗∗ m = ( s t r u c t my struct ∗∗) kmalloc (
num elementos ∗ s i z e o f ( s t r u c t my struct ∗) ,
GFP KERNEL) ;
my struct cache = kmem cache create ( "my_struct_cache"
, s i z e o f ( s t r u c t my struct ) , 0 , SLAB HWCACHE ALIGN
, NULL) ;
i f ( ! my struct cache )
r e t u r n −ENOMEM;
f o r ( ; i < num elementos ; i++)
{
m[ i ] = kmem cache alloc ( my struct cache ,
GFP KERNEL) ;
}

slab cache
Atividade: Alocando objetos com kmalloc e slab
Nesta atividade iremos praticar a cria¸cão, aloca¸cão e libera¸cão de
recursos utilizando kmalloc e slab
Criar 1 módulo que receba como parâmetro de inicializa¸cão o
número de objetos a serem alocados
Deve-se definir uma struct que possua pelo menos 2 elementos
A partir do número de objetos, deve-se construir um array e
cada posi¸cão do array deve ser alocado
Metade dos elementos deve ser alocado via kmalloc e a outra
metade via
Deve ser implementado o processo de desaloca¸cão dos objetos
da maneira apropriada

Conceitos

Conceitos
O uso de estruturas de dados no Kernel
O Kernel, assim como qualquer software, faz uso massivo de
estruturas de dados de modo a armazenar seus dados dado em
runtime
Sendo assim, afim de evitar que o desenvolvedor tenha de
criar suas próprias estruturas a cada desenvolvimento foram
desenvolvidas algumas estruturas de dados básica que podem
ser reutilizadas
São elas:
Linked lists
Queues
Maps
Binary trees
A seguir daremos um enfoque nas listas ligadas! :)

Conceitos
Listas ligadas (Linked Lists)
É a estrutura de dados mais simples e comum encontrada no
Kernel
Diferentemente de um array é uma estrutura expans´ıvel
Faz uso do conceito de nós que apontam para outros nós
As listas ligadas podem se dividir em quatro grupos:
Listas simples
Listas duplamente ligadas
Listas circulares simples
Listas circulares duplamente ligadas

Conceitos
Listas simples
s t r u c t l i s t e l e m e n t {
void ∗ data ; /∗ the payload ∗/
s t r u c t l i s t e l e m e n t ∗ next ; /∗ p o i n t e r to the next
element ∗/
};

Conceitos
Listas duplamente ligadas
s t r u c t l i s t e l e m e n t {
void ∗ data ; /∗ the payload ∗/
s t r u c t l i s t e l e m e n t ∗ next ; /∗ next element ∗/
s t r u c t l i s t e l e m e n t ∗ prev ; /∗ p r e v i o u s element ∗/
};

Conceitos
Listas circulares simples
Figura: Lista circular simples
Figura: Lista circular duplamente ligada

Linked list
A implementa¸cão do Kernel
Em geral, as implementa¸cões de listas ligadas são feitas
tornando a carga útil um elemento da lista
s t r u c t my struct {
unsigned long param1 ;
unsigned long para2 ;
bool param3 ;
s t r u c t my struct ∗ next ;
s t r u c t my struct ∗ prev ;
};
Ao invés disso, a implementa¸cão do kernel adiciona a lista ligada à
estrutura de carga útil

Linked list
A implementa¸cão do Kernel
s t r u c t my struct {
bool param3 ;
s t r u c t l i s t h e a d l i s t ;
};
list head é composta por apenas dois elementos e é definida em
linux/list.h
s t r u c t l i s t h e a d {
s t r u c t l i s t h e a d ∗ next
s t r u c t l i s t h e a d ∗ prev ;
};

Linked list
Definindo uma lista ligada
1 Definir a estrutura de carga útil
2 Atribuir os valores do primeiro elemento da lista
3 Invocar a macro INIT LIST HEAD para inicializar a lista
Por que é necessária a existência de uma macro para inicializa¸cão
da lista?

Linked list
1 Definir a estrutura de carga útil
2 Atribuir os valores do primeiro elemento da lista
3 Invocar a macro INIT LIST HEAD para inicializar a lista
Por que é necessária a existência de uma macro para inicializa¸cão
da lista?
Porque é necessária a aloca¸cão da memória para o primeiro
elemento list head

Linked list
s t r u c t my struct ∗ payload ;
payload = kmalloc ( s i z e o f (∗ payload ) , GFP KERNEL) ;
payload−>param1 = 40;
payload−>param2 = 6;
payload−>param3 = f a l s e ;
INIT LIST HEAD(&payload−> l i s t ) ;
Se estiv´essemos trabalhando com elementos est´aticos criar´ıamos da
seguinte maneira
s t r u c t my struct payload = {
. param1 = 40 ,
. param2 = 6 ,
. l i s t = INIT LIST HEAD ( payload . l i s t ) ,
};

Linked list
Forma alternativa
Na estrutura criada não é feita nenhuma diferencia¸cão entre
qual elemento é a “cabe¸ca” da lista
Porém, muitas vezes queremos manter esse registro
Podemos fazer isso a partir da macro LIST HEAD
s t a t i c LIST HEAD( head ) ;
A partir disso é criado um elemento estático list head

Linked list
Fun¸cões para adicionar elementos na lista
Existem basicamente dois métodos para inser¸cão de elementos da
lista
list add(struct list head *new, struct list head *head)
list add tail(struct list head *new, struct list head *head)
LIST HEAD( head ) ;
s t r u c t my struct ∗ element = . . . // Objeto alocado e com
os parâmetros setados
l i s t a d d (&element−>l i s t , &head ) ;

Linked list
Algumas outras fun¸cões para manipula¸cão
list del
list del init
list move
list move tail
list empty: checa se a lista está vazia

Linked list
Algumas outras fun¸cões para manipula¸cão
list del
list del init
list move
list move tail
list empty: checa se a lista está vazia
Mas afinal, como recuperamos a carga útil tendo referência apenas
ao list head?
Fazemos uso da fun¸cão list entry(ptr, type, member), onde
ptr: ponteiro list head
type: tipo da carga útil
member: nome do elemento list head dentro da carga útil

Linked list
Curiosidade: o funcionamento da fun¸cão list entry
Trata-se de uma macro que consegue obter o endere¸co da
estrutura externa a partir de um elemento interno
Faz uso do deslocamento (offset) apresentado pelo elemento
interno em rela¸cão à estrutura externa
#d e f i n e l i s t e n t r y ( ptr , type , member) ({
const typeof ( (( type ∗) 0)−>member ) ∗ mptr = ( ptr ) ;
( type ∗) ( ( char ∗) mptr − o f f s e t o f ( type , member) ) ; } )

Linked list
Percorrendo a lista
O Kernel disponibiliza um conjunto de macros que possibilitam a
itera¸c˜ao na lista de maneira bastante simples
list for each, list for each entry, list for each entry reverse
s t r u c t l i s t h e a d ∗p ;
s t r u c t my struct ∗ f ;
l i s t f o r e a c h (p , &head ) {
/∗ f aponta para a carga u t i l dos elementos ∗/
f = l i s t e n t r y (p , s t r u c t my struct , l i s t ) ;
}

Linked list
Atividade 3: trabalhando com listas ligadas
Iremos trabalhar nesta atividade no processo de cria¸cão e utiliza¸cão
de listas ligadas
Em um dos módulos criados na se¸cão 1 adicione rotinas que
criem, populem, iterem e realizem dele¸cão sobre uma lista
A estrutura deve ser definida em um arquivo .h bem como as
rotinas do módulo

Linked list
Bibliograﬁa I
Jeremy Andrews.
Linux: Documenting how patches reach the kernel.
http://kerneltrap.org/node/3180, Maio 2004.
The Git Community Book.
The git community book.
http://book.git-scm.com/index.html, Outubro 2011.
Ariejan de Vroom.
How to create and apply a patch with git.
http://ariejan.net/2009/10/26/
how-to-create-and-apply-a-patch-with-git/, Outubro
2009.

Linked list
Bibliograﬁa II
Wikipedia Foudation.
Sco-linux controversies.
http:
//en.wikipedia.org/wiki/SCO-Linux_controversies,
Outubro 2011.

Kernel Linux Programação Parte 1

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (20)

Similaire à Kernel Linux Programação Parte 1

Similaire à Kernel Linux Programação Parte 1 (20)

Plus de Ivo Calado

Plus de Ivo Calado (10)

Kernel Linux Programação Parte 1