Linux (kernel)

Origem: Wikipédia, a enciclopédia livre.

Linus Torvalds, criador do kernel Linux.

O Linux é um kernel de sistema operativo compatível com Unix. Foi criado por Linus Torvalds em 1991 e subseqüentemente desenvolvido com a ajuda de programadores de todo o mundo como software livre (SL).

Foi inicialmente desenvolvido para o processador Intel 80386 (arquitetura x86), mas tem sido adaptado para muitas plataformas, desde dispositivos embarcados (ex. CRIS, da Axis), até computadores de grande porte (ex. S/390 da IBM), passando por processadores com arquiteturas x86-64 (AMD e Intel), IA-64 (Itanium da Intel) e RISC (ex. UltraSPARC da Sun e PowerPC da IBM-Motorola). É quase na totalidade escrito em C com algum código Assembly, quando necessário, principalmente por causa de desempenho e especificidades da plataforma.

Índice

1 História
2 Características técnicas
3 Miscelânea
- 3.1 Mascote
- 3.2 Termos de licenciamento
4 Referências
5 Ligações externas
- 5.1 Linux 2.6
- 5.2 Páginas com atalhos para recursos do núcleo

[editar] História

O projecto foi lançado em 1991 com a famosa mensagem enviada ao grupo de discussão da Usenet comp.os.minix que incluia a seguinte frase:

"Estou a fazer um sistema operativo (grátis) (é só um passatempo, não será grande e profissional como o Projecto GNU) para clones de 386(486)AT..."

Naquela altura, o Projecto GNU havia criado muitos dos componentes necessários a um sistema operativo livre, mas o seu núcleo, o GNU Hurd, ainda não tinha sido completado e estava assim indisponível. O sistema operativo BSD ainda não se tinha liberto de complicações legais. Isso abriu espaço para o Linux preencher, e apesar da funcionalidade limitada das versões iniciais, acumulou rapidamente desenvolvedores e utilizadores.

[editar] Versões

Este diagrama, criado com o Free Code Graphing Project, é o que mais próximo existe de uma fotografia do kernel Linux, na sua versão 2.4.0

Torvalds e sua equipe têm continuado a lançar novas versões, consolidando contribuições de outros programadores e introduzindo alterações suas. Antes do lançamento do kernel 2.6, o número de versão menor (o segundo componente) par indicavam uma série estável: 1.0.x, 1.2.x, 2.0.x, 2.2.x e 2.4.x; os lançamentos com um número de versão menor ímpar correspondiam a versões de desenvolvimento. O terceiro componente do número de versão correspondia a correções (releases) da versão. A partir da versão 2.6, Torvalds alterou esse padrão, criando um quarto dígito. Assim, a árvore estável e a de desenvolvimento confundem-se. Atualmente, considera-se uma versão tanto mais estável quanto maior o quarto dígito. Enquanto que Torvalds continua a lançar as versões de desenvolvimento mais recentes, a manutenção das versões "estáveis" mais antigas é delegada a outros, incluindo David Weinehal (2.0), Alan Cox e mais tarde Marc-Christian Petersen (2.2), Marcelo Tosatti e depois Willy Tarreau (2.4) e o próprio Torvalds, Andrew Morton e Adrian Bunk (2.6). Para além dos núcleos "oficiais", "árvores" alternativas podem ser obtidas de outras fontes. Distribuidores de sistemas operativos completos mantém as suas próprias versões do Linux, onde, por exemplo, incluem drivers que não se encontram incluidos na versão oficial.

[editar] Versões iniciais

0.01 - Setembro de 1991: primeira versão.
0.12 - Janeiro de 1992: primeira versão sob GPL.

[editar] Versões estáveis

1.0 - Março de 1994 suportava apenas máquinas monoprocessadas i386. (176.250 linhas de código)
1.2 - Março de 1995 incluído suporte para Alpha, Sparc e Mips. (310.950 linhas de código)
2.0 - Junho de 1996 incluído suporte para mais processadores e foi incluído suporte para SMP (777.956 linhas de código)
2.2 - Janeiro de 1999 (1.800.847 linhas de código)
2.4 - Janeiro de 2001 (3.377.902 linhas de código)
2.6 - Dezembro de 2003 (5.929.913 linhas de código)

[editar] Características técnicas

[editar] Arquitetura

O Linux é um kernel monolítico com suporte a módulos carregáveis. Inclui capacidade de multitarefa, multiprocessamento, memória virtual por paginação, bibliotecas compartilhadas, copy-on-write.

Os drivers de dispositivos e extensões do núcleo correm tipicamente no espaço do kernel, juntamente com o restante do núcleo, com acesso total ao hardware. Diferentemente dos núcleos monolíticos tradicionais, os drivers de dispositivos podem ser configurados como módulos, o que permite que sejam carregados e descarregados enquanto o sistema corre. Também podem ser interrompidos (preempted) sob certas condições. Esta característica foi adicionada para lidar com interrupções de hardware correctamente e para melhorar o suporte ao multiprocessamento.

O facto do Linux não ser microkernel foi tema duma famosa discussão entre Linus Torvalds e Andy Tanenbaum no grupo de discussão de Usenet comp.os.minix em 1992 [6].

[editar] Processos

Um processo é uma instância de um programa em execução [2]. Todo processo no Linux tem um pai (processo criador) e um número identificador (PID). O pai de todos os processos num ambiente Linux é o init, cujo PID é 1. Este processo é criado pelo processo 0, que é um encadeamento (thread) do próprio kernel. O processo init irá permanecer em execução até o desligamento do sistema, e sua função é monitorar e criar os processos que implementam as camadas exteriores do sistema operacional [3].

Os processos são criados pela chamadas de sistema fork() (processos tradicionais ou heavy weight) e clone() (processos leves ou light weight). Para otimizar a criação de processos tradicionais, o Linux usa o recurso de copy-on-write: quando um processo-filho é criado, ele compartilha as mesmas páginas de memória do pai. Quando um dos dois tenta escrever na memória, é gerada uma interrupção para o kernel, que então copia o conteúdo das páginas de memória para novas molduras de páginas, e estas são atribuídas ao processo que efetuou a escrita.

Para manter um ambiente multitarefa e possibilitar o multiprocessamento, o Linux mantém algumas estruturas importantes, das quais podemos citar duas: (i) o descritor do processo (task_struct), que contém todas as informações relativas ao processo; (ii) uma fila (runqueue) de processos por processador. Quando o sistema possui mais de um processador, o agendador do Linux faz o balanceamento de carga entre as filas.

[editar] Agendamento

Para poder fazer um adequado compartilhamento de tempo do processador, o Linux usa duas classificações para avaliar qual a prioridade que um processo deve ter: (i) determina a responsividade do processo (tempo real, interativo, em segundo plano); (ii) verifica se o processo usa muito tempo de processador (CPU-bound) ou faz muitas operações de entrada e saída (I/O-bound) [3].

Essas duas classes são razoavelmente independentes. Um processo pode executar em segundo plano (um daemon, por exemplo) e ser consumidor de recursos de entrada e saída (um servidor de banco de dados) ou usar muito tempo de processador (um compilador). Um processo que executa em tempo real foi assim definido pelo seu programador, mas o agendador do Linux necessita fazer uma análise heurística para saber se um processo é interativo ou está executando em segundo plano.

O Linux utiliza um sistema de prioridades, onde um processo que possui prioridade maior tem precedência sobre um de prioridade menor para obter o processador. A identificação da prioridade de um processo pode ser estática ou dinâmica e varia de 1, a maior prioridade, a 139, a menor. Os números 1 a 99 são atribuídos a processos de tempo real e 100 a 139 são atribuídos a processos tradicionais (interativos e segundo plano).

Um processo em tempo real é classificado em FIFO (first-in, first-out) ou RR (Round-Robin) e somente será retirado do processador nos seguintes casos: (i) fim de execução; (ii) para ser substituído por um processo de maior prioridade; (iii) executar uma operação de bloqueio; (iv) espontaneamente; (v) é RR e esgotou seu quantum de processamento.

Um processo tradicional tem inicialmente atribuída uma prioridade estática (em geral 120) que determina o seu quantum de processamento, mas pode ter uma prioridade dinâmica, que é o valor analisado pelo agendador quando percorrer a lista de processos para determinar qual irá usar o processador. A prioridade dinâmica pode alterar o valor da prioridade estática em 5 pontos, para mais (penalidade) ou para menos (bônus), dependendo do passado do processo. O passado irá beneficiar o processo se o mesmo ficou muito tempo fora do processador (sleep time). Caso este tempo seja pequeno, o processo será penalizado.

[editar] Gerenciamento de memória

O Linux utiliza memória virtual, que possui 3 funções básicas: (i) assegurar que cada aplicação (processo) tenha seu próprio espaço de endereçamento, começando em zero (problema de relocação [1]); (ii) proteção de memória, para impedir que um processo utilize um endereço de memória que não lhe pertença; (iii) possibilitar que uma aplicação utilize mais memória do que a fisicamente existente (essa é a função mais óbvia).

Seu código divide-se em duas partes. Uma é dependente da arquitetura, onde são definidos o endereçamento – virtual e físico, o tamanho de página e o tratamento das tabelas de páginas. Na parte independente ficam o controle de alocação e liberação de memória e o esquema de substituição páginas.

O Linux utiliza tamanhos de páginas de acordo com a arquitetura. Os processadores x86 utilizam páginas de 4 KiB (padrão), 2 MiB (caso seja utilizado o recurso de PAE – Page Address Extension – da Intel) ou de 4 MiB. Nas arquiteturas RISC o tamanho padrão é de 8 KiB, mas não é o único.

O endereçamento virtual é dividido em espaço do usuário e espaço do kernel. O primeiro é privativo de cada processo, com início no endereço lógico zero e terminando no endereço determinado pela macro PAGE_OFFSET (v. figura 1). O espaço do kernel é único e começa depois do espaço do usuário. Na arquitetura x86 PAGE_OFFSET determina um valor de 3 GiB para o espaço do usuário e 1 GiB para o espaço do kernel.

(Figura 1: está faltando)

O código do kernel é carregado no início do espaço do kernel, sendo seguido pela área fisicamente mapeável (mem_map, estrutura que indexa as páginas físicas, e as páginas propriamente ditas). Na arquitetura x86, os últimos 128 MiB do espaço do kernel são reservados para alocação de memória não contígua e memória alta, limitando a memória física endereçável pelo kernel padrão a 896 MiB.

Um endereço virtual no Linux (v. figura 2), é dividido em 5 campos: diretório de páginas (PGD), diretório superior de páginas (PUD), diretório intermediário de páginas (PMD), tabela de páginas (PTE) e deslocamento (offset). A arquitetura x86 possui um espaço de endereçamento de 32 bits; quando são utilizadas páginas de 4 KiB (o padrão) o PUD e o PMD não são utilizados; o PGD e o PTE usam 10 bits cada, e o deslocamento usa 12 bits.

(Figura 2: está faltando)

O esquema de substituição de páginas no Linux usa o algoritmo LRU (por aproximação) mantendo duas listas de envelhecimento (aging). A primeira (active_list) contém as páginas atualmente em uso (as páginas mais recentemente referenciadas estarão mais próximas do início da lista) e a segunda (inactive_list) contém as candidatas a paginação (page out).

A paginação para disco pode ocorrer sob demanda, quando algum processo solicitar página e não houver alguma disponível. Neste caso, a página no final da lista inactive_list é liberada. Entretanto, existe um processo chamado kswapd, inicializado pelo kernel, que verifica, periodicamente, o número de páginas livres. Caso este número seja menor que pages_low, kswapd é acordado para liberar páginas. Se o valor chegar a pages_min, kswapd entra num regime síncrono para agilizar a liberação. Quando o valor de páginas livres atingir pages_high, kswapd vai dormir.

[editar] Pânico do núcleo (Kernel Panic)

Um pânico é um erro de sistema não-recuperável detectado pelo kernel, ao contrário dos erros de impressão e utilização por código do espaço de utilizador. É possível que o código do núcleo indique essa condição ao invocar a função panic localizada no ficheiro-cabeçalho sys/system.h. No entanto, grande parte dos pânicos são o resultado de excepções do processador não-lidadas no código do kernel, tal como referências a moradas de memória inválidas. São normalmente não indicativo de erros algures na cadeia de chamadas que levam ao pânico.

[editar] Miscelânea

[editar] Mascote

Tux, símbolo do projeto

A mascote do Linux (núcleo e tudo que é relacionado) é um pinguim chamado Tux, criado por Larry Ewing. O motivo pelo qual a mascote é um pinguim é, como Torvalds disse, "O Linus gosta de pinguins. É isso." O nome Tux foi sugerido para representar Torvalds' Unix, e ficou assim.

[editar] Termos de licenciamento

Inicialmente, Torvalds lançou o núcleo de Linux sob uma licença que proibia qualquer exploração comercial mas mais tarde adoptou a GPL (versão 2 exclusivamente). Esta licença permite a distribuição e até a venda de versões do núcleo de Linux mas exige que todas essas cópias sejam lançadas sob a mesma licença e que sejam acompanhadas com o código-fonte. Torvalds descreveu o licenciamento do núcleo de Linux sob a GPL como "a melhor coisa que fez desde sempre." Uma dúvida que é levantada na aplicação da GPL no núcleo de Linux é a consideração sob a lei de direitos de autor de módulos carregaveis como sendo ou não "trabalho derivado" e, consequentemente, serem submetidos aos termos da GPL. Torvalds declarou que módulos que usam apenas um conjunto público e limitado do interface do núcleo podem, por vezes, ser trabalho não-derivado, assim permitindo alguns "drivers" distribuídos apenas em formato binário e outros módulos que não respeitem os termos da GPL. Contudo, nem todos os contribuintes do núcleo concordam com esta interpretação e até Torvalds concorda que muitos módulos do núcleo são claramente obras derivadas.

[editar] Referências

[1] TANENBAUM, Andrew. Sistemas operacionais modernos. Rio de Janeiro: LTC. 1999.
[2] SILBERSCHATZ, Avi; GALVIN, Peter B.; GAGNE, Greg. Operating system concepts. 7.ed. Hoboken: Wiley. 2005.
[3] BOVET, Daniel P.; CESATI, Marco. Understanding the Linux kernel. 3.ed. Sebastopol: O'Reilly. 2005.
[4] GORMAN, Mel. Understanding the Linux virtual memory manager. New Jersey: Prentice Hall. 2004.
[5] TORVALDS, Linus; DIAMOND, David (2001). Just For Fun: The story of an accidental revolutionary. HarperBusiness. ISBN 0066620724 (hardcover); HarperAudio ISBN 0694525391 (audio tape, abridged ed., read by David Diamond) - on the beginnings of the Linux kernel; No Brasil: Só por Prazer. Campus. ISBN 85-352-0801-1.
[6] DiBONA, Chris; OCKMAN, Sam; STONE, Mark. Open sources: voices from the open source revolution. Sebastopol: O'Reilly. 1999.