Linux (kernel)

Moderador: Moderador

Responder
Avatar do Utilizador
Barefaced
Administrador
Administrador
Mensagens: 33278
Registado: 06 jul 2007, 17:43
Localização: @ Home
Contacto:

Linux (kernel)

Mensagem por Barefaced » 07 set 2007, 04:26

Imagem
Linux (kernel)

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

Imagem
Linus Torvalds, criador do kernel Linux.

Foi inicialmente desenvolvido para o processador Intel 80386 (arquitectura 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 arquitecturas 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.

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 incluía 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.

Versões

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 correcçõ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. Actualmente, 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 incluídos na versão oficial.

Imagem
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

Versões Iniciais

» 0.01 - Setembro de 1991:
- Primeira Versão.

» 0.12 - Janeiro de 1992:
- Primeira Versão sob GPL.

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)

Imagem
Um diagrama simplificado do kernel Linux, mostrando seus componentes principais e as camadas que o cercam.

Arquitectura

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.

Todo acesso ao kernel por uma aplicação deve ser efectuado por meio de chamadas de sistema. Uma chamada de sistema é uma função do kernel que permite a criação de processos, solicitação de memória, operação com arquivos, etc.

Já a comunicação do kernel com o hardware ocorre, basicamente, de dois modos: (i) o kernel reconhece e gerencia o hardware usando drivers de dispositivos; (ii) o hardware comunica-se com o kernel por meio de interrupções.

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.

Processos

Um processo é uma instância de um programa em execução. 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.

Os processos são criados pela chamadas de sistema fork () (processos tradicionais ou heavy weight) e clone() (processos leves ou light weight). Para optimizar 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 efectuou 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.

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 responsabilidade do processo (tempo real, interactivo, 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).

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 é interactivo 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 (interactivos 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.

Obs.: essa estrutura acima pode ser modificada a partir da release 2.6.23 ou posterior, com a introdução do CFS (completely fair scheduler).

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 recolocação [1]); (ii) protecçã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 arquitectura, 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 colocação e libertação de memória e o esquema de substituição páginas.

O Linux utiliza tamanhos de páginas de acordo com a arquitectura. 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 arquitecturas RISC o tamanho padrão é de 8 KiB, mas não é o único.

O endereçamento virtual é dividido em espaço do utilizador 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. O espaço do kernel é único e começa depois do espaço do usuário. Na arquitectura 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.

Imagem

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 arquitectura x86, os últimos 128 MiB do espaço do kernel são reservados para colocaçã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, é dividido em 5 campos: directório de páginas (PGD), directório superior de páginas (PUD), directório intermediário de páginas (PMD), tabela de páginas (PTE) e deslocamento (offset). A arquitectura 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.

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 actualmente 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 é libertada. 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 libertar 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.

Sistema de arquivos

O gerenciamento de arquivos no Linux baseia-se num esquema de vários níveis, onde a camada principal é o VFS (Virtual File System Switch), que esconde da aplicação as características dos diversos sistemas de arquivo (SA) reconhecidos pelo Linux. Quando uma aplicação solicita uma operação sobre algum arquivo, essa solicitação é encaminhada para o VFS, que reenvia a solicitação para um dos SA registrados.

O VFS utiliza uma estrutura chamada superbloco para manter as informações referentes aos diversos SAs montados (tipo, ponto de montagem, dispositivo de bloco utilizado, arquivos abertos). Também utiliza nós-i, semelhantes aos nós-i do EXT2, com as informações sobre os arquivos (permissões, blocos utilizados, dono, etc.).

Os SAs registrados no VFS podem ser classificados em 3 grupos: (i) dispositivos de blocos (EXT2, EXT3, Reiserfs, XFS, VFAT); (ii) associados a rede (NFS, SMB); (iii) dispositivos especiais (proc, tempfs). Todos esses SAs podem ser carregados como módulos.

O SA Ext2 está deixando de ser o padrão, particularmente por sua deficiência quando ocorre uma anomalia. Neste caso, o sistema operacional deve executar uma varredura completa para verificar o estado do SA (fsck). Outros SA foram criados para sanar essa deficiência, utilizando um recurso chamado journaling, que é a utilização de um log de alterações (journal). Os SAs desse tipo mais importantes são o Ext3, Reiserfs, XFS e JFS.

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.


Generalidades

Mascote

Imagem
Tux, símbolo do projecto.

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.

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 carregáveis 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.

Ligações Externas

www.kernel.org - The Linux Kernel Archives, the official kernel repository
Linux Kernel HowTo
Kernel Traffic, a summary of the high-traffic Linux kernel mailing list
KernelTrap
Cobertura sobre o kernel em LWN.net
Linux Kernel Source Code Viewer
Linux Kernel Janitor
Linux Device Drivers, 3rd Edition
Understanding the Linux Kernel, 2nd Edition
LinkSys and binary modules, LWN.net Weekly Edition, October 16, 2003.

Linux 2.6

Upgrade to 2.6 kernel
The Wonderful World of Linux 2.6; Joseph Pranevich; December 2003
O Maravilhoso Mundo do Linux 2.6; tradução do artigo acima por Cesar A. K. Grossmann
Understanding the Linux 2.6.8.1 CPU Scheduler; Josh Aas, 17th February 2005

Páginas com Atalhos para Recursos do Núcleo

http://www.linux.org/dist/kernel.html
Linux kernel @ dmoz.org
Linux kernel @ google
http://www.linuxlinks.com/Kernel/
http://loll.sourceforge.net/linux/links/Kernel/
Linux Kernel Developers' email list
Kernel Newbies.org
http://www.topology.org/soft/lkernel.html



Informação de:
Imagem

Compilação por:
Barefaced


ImagemImagemImagemImagem
Imagem

Responder

Voltar para “Software free e Opensource”

Quem está ligado:

Utilizadores neste fórum: Nenhum utilizador registado e 2 visitantes