Álvaro perez sanchez, cleber lopes campomori, josé marcos...
TRANSCRIPT
FACULDADE DE TECNOLOGIA DE GUARATINGUETÁ
SISTEMA OPERACIONAL LINUX
Álvaro Perez Sanchez, Cleber Lopes Campomori, José
Marcos Rocca, Pedro Aurélio Lemes
Trabalho apresentado na disciplina “Sistemas
Operacionais 2” para o professor José Geraldo, no curso
superior de Tecnologia em Informática, 4° semestre
noturno.
Guaratinguetá – SP
2011
FACULDADE DE TECNOLOGIA DE GUARATINGUETÁ
SISTEMA OPERACIONAL LINUX
Álvaro Perez Sanchez, Cleber Lopes Campomori, José
Marcos Rocca, Pedro Aurélio Lemes
Trabalho apresentado na disciplina “Sistemas
Operacionais 2” para o professor José Geraldo, no curso
superior de Tecnologia em Informática, 4° semestre
noturno.
Área de concentração: Sistemas Operacionais
Guaratinguetá – SP
2011
LISTA DE ILUSTRAÇÕES
Figura 1 - Ken Thompson e Dennis Ritchie ................................................................. 10
Figura 2 - Linus Torvalds ............................................................................................. 11
Figura 3 - Mascotes GNU e Linux (Tux) ..................................................................... 12
Figura 4 - Richard Stallman .......................................................................................... 12
Figura 5 - Logotipo do Debian ..................................................................................... 14
Figura 6 - Logotipo Ubuntu .......................................................................................... 15
Figura 7 - Logotipo Damn Small Linux ....................................................................... 15
Figura 8 - Logotipo Endian Firewall ............................................................................ 16
Figura 9 - Logotipo Android ......................................................................................... 17
Figura 10 - Esquema de gerenciamento de memória através [...] ................................. 30
SUMÁRIO
1 INTRODUÇÃO: O QUE É LINUX? ................................................................................... 9
2 HISTÓRICO ........................................................................................................................ 10
2.1. Antecessores, Multics e Unix .......................................................................................... 10
3 DISTRIBUIÇÕES LINUX ................................................................................................. 13
3.1. O que são disitribuições .................................................................................................. 13
3.2. Exemplos de distribuições ............................................................................................... 13
3.2.1. Debian ............................................................................................................................ 14
3.2.2. Ubuntu ........................................................................................................................... 14
3.2.4. Endian Firewall ............................................................................................................ 16
3.2.5. Android .......................................................................................................................... 16
4 DETALHES DO SISTEMA OPERACIONAL LINUX .................................................. 18
4.1. Sistema de arquivos ......................................................................................................... 18
4.1.1. Linux EXT2 ................................................................................................................... 18
4.1.2. Linux EXT3 ................................................................................................................... 19
4.1.3. Funcionalidades do Linux EXT3 ................................................................................ 20
4.1.4. Desfragmentação do Linux EXT3 ............................................................................... 21
4.1.5. Recuperação no Linux EXT3 ...................................................................................... 21
4.1.6. Compressão no Linux EXT3 ....................................................................................... 21
4.1.7. Linux EXT4 ................................................................................................................... 22
4.1.8. Sistemas de arquivos ou arquivos grandes ................................................................. 23
4.1.9. Escalabilidade de subdiretórios ................................................................................... 23
4.1.10. Extends ........................................................................................................................ 23
4.1.11. Alocação multiblock ................................................................................................... 24
4.1.12. Atraso na alocação ...................................................................................................... 25
4.1.13. FSCK rápido ............................................................................................................... 25
4.1.14. Journal checksumming .............................................................................................. 26
4.1.15. Recursos relacionados aos inodes .............................................................................. 26
4.1.16. Presistência na pré-alocação ...................................................................................... 27
4.1.17. ReiserFS ....................................................................................................................... 28
4.1.18. Desvantagens do ReiserFS ......................................................................................... 28
4.2. Gerenciamento de memória ............................................................................................ 29
4.3. Gerenciamento de processos ........................................................................................... 32
4.3.1. O conceito de processo ................................................................................................. 32
4.3.2. Os primeiros processos ................................................................................................. 33
4.3.3. Estados ........................................................................................................................... 34
4.3.4. Limite de recursos ........................................................................................................ 35
4.3.5. Preemptivo .................................................................................................................... 36
4.3.6. Política de escalonamento ............................................................................................ 37
4.3.7. Algoritmo de Escalonamento ....................................................................................... 38
5 VANTAGENS E DESVANTAGENS DO LINUX ............................................................ 39
5.1 Vantagens .......................................................................................................................... 39
5.2 Desvantagens ..................................................................................................................... 40
6 CONCLUSÕES .................................................................................................................... 41
7 BIBLIOGRAFIA ................................................................................................................. 42
1 INTRODUÇÃO: O QUE É LINUX?
Linux é um sistema operacional, responsável pelo funcionamento do computador, que
faz a comunicação entre hardware (impressora, monitor, mouse, teclado) e software
(aplicativos em geral).
O kernel é o coração do Sistema Operacional Linux. Ele é o responsável por garantir
que todos os programas terão acesso aos recursos de que necessitam (memória RAM, por
exemplo) simultaneamente, fazendo com que haja um compartilhamento concorrente – mas
sem oferecer riscos à integridade da máquina. O conjunto de um kernel e demais programas
responsáveis pela comunicação com este é o que denominamos sistema operacional.
Desenvolvido pelo finlandês Linus Torvalds, o Linux tem seu código fonte disponível
sob licença GPL para qualquer pessoa utilizar, estudar, modificar e distribuir de acordo com
os termos da licença. O Linux é um sistema operacional derivado do Unix.
2 HISTÓRICO
O nome Linux é uma fusão do nome de seu criador, o finlandês Linus Torvalds com
Unix, um sistema operacional de grande porte voltado para servidores, no qual o Linux foi
baseado. Para entender a história do Linux é preciso um breve resumo sobre a história do
Unix.
2.1. Antecessores, Multics e Unix
O Unix e sua história estão intrinsicamente ligados a história de um sistema
operacional mais antigo, chamado Multics, o Multics foi criado na década de 1960 por um
conjunto de empresas entre elas General Eletric (GE), laboratórios Bell (Bell Labs) e
American Telephone an Telegraph (AT&T) além do Massachusets Institute of Technology
(MIT). A idéia principal do Multics era quanto as características de tempo compartilhado,
aonde vários usuários usam os recursos do computador ao mesmo tempo, compartilhando-o.
Ken Thompsom, um dos pesquisadores do Multics que trabalhava na Bell, após a saída da
referida empresa do projeto Multics, decidiu que desenvolveria um sistema que mantesse as
mesmas características do Multics mas que fosse menor do que o anterior, nasceu então o
Unix. Algum tempo mais tarde em 1973 um outro pesquisador da Bell, Dennis Ritchie,
reescreveu todo o sistema em uma linguagem de alto nível que ele mesmo criou, o C, isto fez
com que o Unix passasse a ter maior aceitação fora da Bell.
Figura 1 - Ken Thompson e Dennis Ritchie
Entre 1977 e 1983 a AT&T passou a alterar o Unix de modo a poder comercializar o
mesmo, isto se deu em meados de 1983 com o desenvolvimento da versão System V que até
hoje ainda é usado no mercado.
Em 1991 Linus Torvalds, então estudante de Ciências da Computação na Universidade
de Helsinki na Finlândia, começa a estudar o Minix uma versão livre do Unix, então o mesmo
decide criar um sistema que fosse mais poderoso que o Minix, para isso envia uma mensagem
através da Usenet (espécie de antecessor da Internet), divulgando sua idéia, aonde já propõe a
colaboração no desenvolvimento do sistema, bem como a disponibilização dos códigos
fontes, Ainda em 1991 disponibiliza a versão 0.02 do Kernel (núcleo do sistema), e continua
trabalhando até finalmente em 1994 oferecer a versão 1.0.
O Linux é um Sistema Operacional livre, que reimplementa as especificações POSIX,
que já eram usadas em sistemas Unix (System 4) e BSD. Deste modo o Linux é muito similar
ao Unix, mas seu fonte é completamente distinto tendo sido escrito de formas completamente
diferentes e separadas.
Figura 2 - Linus Torvalds
Linus Torvalds ao desenvolver o Linux não tinha intenção de ganhar dinheiro a
intenção primordial era desenvolver um sistema que atendesse as suas necessidades pessoais,
além é claro da pesquisa. Desde o começo o estilo de desenvolvimento foi baseado na ajuda
coletiva, aonde vários desenvolvedores são coordenados por Linus, de forma colaborativa
melhorando o sistema que ele criou. Milhares de pessoas no mundo ajudaram e ainda ajudam
a desenvolver o Linux apenas pelo prazer de se criar um sistema cada vez melhor, isso faz
dele a potência que é nos quesitos estabilidade e segurança.
O Linux é regido pela licença GPL a referida licença basicamente dita que qualquer
um pode usar o programa desde que não o torne fechado. Ou seja, você pode alterar e até
comercializar o programa, mas nunca fechar o seu código.
A história do Linux ainda se funde a do GNU, o GNU é um projeto que começou em
1984 por Richard Stallman com o objetivo de desenvolver um sistema compatível com Unix
(Unix-like). O Linux é apenas um kernel (núcleo do sistema) o GNU é um conjunto de
softwares, que foram até mesmo usados por Linus no desenvolvimento do Linux. Deste modo
o sistema acabou se fundindo, se tornando uma junção do Kernel (Linux) e demais itens do
Sistema (GNU). Deste modo o sistema leva usualmente o nome de seu núcleo, o Linux, mas o
termo correto é GNU/Linux.
Figura 3 - Mascotes GNU e
Linux (Tux)
Figura 4 - Richard Stallman
3 DISTRIBUIÇÕES LINUX
3.1. O que são disitribuições
Entende-se como sistema operacional, um software que como um todo é capaz de
fazer o computador funcionar de forma útil, provendo acesso aos dispositivos de hardware
disponíveis, bem como fornecendo programas e aplicações para a interação do usuário nas
mais diversas aplicações. As distribuições são a junção de todos esses fatores, núcleo do
sistema (kernel Linux), programas (ex: Shell), aplicativos (ex: navegador Firefox). O que
difere uma distribuição da outra é a versão utilizada do Kernel, e os programas e aplicativos
disponibilizados, bem como o foco da distribuição, existem distribuições voltadas para todos
os tipos de atividade, servidores, desktop, roteadores de redes, firewall, mobile e etc. Um fato
que deixa claro a diferença que as distribuições podem ter entre si de acordo com o que
oferecem se baseia no tamanho em bytes de algumas delas, existem distribuições capazes de
“rodar” a partir de um simples disquete de 1.44MB até distribuições que ocupam 3 DVD´s de
4.7GB.
3.2. Exemplos de distribuições
Hoje existem centenas de distribuições voltadas para as mais diversas aplicações,
como citado existem muitas diferenças e peculiaridades entre as elas. Seguem alguns
exemplos, suas funções, peculiaridades e foco principais.
3.2.1. Debian
Debian ou Debian GNU/Linux é uma distribuição focada na estabilidade que existe
desde 1996, atualmente a versão estável se encontra na 6.0 (codinome Squeeze). O Debian
prima por estabilidade, haja visto que há uma cultura de se manter sempre versões antigas e
testadas de todos os pacotes e bibliotecas, garantindo alta confiabilidade, a versão estável da
distro nunca recebe pacotes antes dos mesmos serem exaustivamente testados, isso faz com
que o Debian seja uma distribuição amplamente utilizada em servidores. Outro fator
diferencial do Debian é o gerenciador de pacotes APT que permite a instalação, remoção,
atualização e configuração de pacotes de instalação de forma simples, fácil, eficaz e segura.
3.2.2. Ubuntu
Esta distribuição existe desde 2004, é uma distribuição baseada no Debian, também
utilizando o gerenciador de pacotes APT, tem tido grande destaque no mercado Linux nos
últimos três anos, apresentando grandes facilidades na sua instalação e uso para desktops, as
versões do Ubuntu são lançadas a cada seis meses sempre no mês quatro e no mês dez. O
número das versões obedece a este padrão começando na versão 4.10(ano 2004, mês 10),
5.04(ano 2005, mês 04) e assim sucessivamente. O ubuntu costuma trazer inovações
interessantes aos usuários de desktop a cada nova versão, sendo considero o Linux “mais fácil
de usar”, devido as suas ferramentas intuitivas e bem construídas graficamente. A última
Figura 5 - Logotipo do Debian
versão é a 11.4 (codinome Natty Narwhal), que traz como grande novidade o uso do novo e
polêmico gerenciador de janelas Unity, que promete um Desktop mais produtivo e bonito em
comparação aos demais gerenciadores de janela.
Figura 6 - Logotipo Ubuntu
3.2.3. Damn Small Linux
É uma distribuição baseada no Debian, que faz parte de um tipo denominado “mini-
distribuições”, basicamente se trata de um Linux live-cd (roda direto do CD, sem necessidade
de instalação, sendo possível seu uso até mesmo em computadores sem disco rígido), a
pequena distribuição oferece um desktop pronto e completo, contendo suíte de escritório,
navegador de internet, cliente de mensagens instantâneas entre outros aplicativos. Devido ao
seu tamanho é também muito leve e pode rodar bem no modo denominado “light” em um 486
DX2 de 66 Mhz com 16MB de memória RAM, com uma máquina com 128MB de RAM é
capaz de rodar no seu modo “full” com todos os aplicativos e recursos da distribuição
plenamente funcionais. A distribuição tem pouco mais de 50MB o que permite sua gravação
até mesmo em CD’s do tipo Business Card. Se encontra na versão 4.4.10.
Figura 7 - Logotipo Damn Small Linux
3.2.4. Endian Firewall
Como o próprio nome sugere o Endian é um firewall baseado em Linux que pode
transformar qualquer computador em um poderoso roteador/firewall. Conta com interface
Web unificada de acesso e gerenciamento. Dispõe de ferramentas comuns e avançadas para
firewall e roteamento, como por exemplo NAT, Proxy, DHCP, VPN, Anti-vírus e Anti-Spam
para email e Web, filtro de conteúdo, estatísticas e logs, dentre outras ferramentas. Se
encontra atualmente na versão 2.1.2.
Figura 8 - Logotipo Endian Firewall
3.2.5. Android
Sistema operacional mobile da Google que utiliza o kernel Linux. Não é desenvolvido
internamente no kernel e sim numa estrutura externa desenvolvida pela Google. O sistema foi
desenvolvido inicialmente pela própria Google que posteriormente passou o desenvolvimento
para a Open Handset Alliance, ficando apenas com o gerenciamento do produto e a
engenharia de processos. O Android é desenvolvido com bibliotecas que permite ao
desenvolvedor programar para ele utilizando Java realizando o controle do aparelho por
intermédio dessas bibliotecas. O crescimento do Android foi exponencial no último ano,
atingindo algumas marcas altamente expressivas como: duzentos mil aplicativos
desenvolvidos e disponibilizados no Google Market (loja de aplicativos do Android), cem
milhões de aparelhos Android ativados, quatro bilhões e meio de aplicações instaladas através
do Android Market. Com estes números o Android se tornou a plataforma mais utilizada em
smarthphones estando em primeiro lugar com 38,5% de todo o mercado.
Figura 9 - Logotipo Android
4 DETALHES DO SISTEMA OPERACIONAL LINUX
4.1. Sistema de arquivos
Linus Torvalds adaptou o sistema de arquivos do MINIX, de Andrew Tanenbaum,
para o Linux. Esse sistema de arquivos estendeu o limite do volume para 2 GiB e o tamanho
do nome de arquivo para 255 caracteres.
4.1.1. Linux EXT2
A influência do UNIX pode ser vista, p.ex., na utilização de grupos de blocos, que são
análogos aos grupos de cilindros utilizados pelo FFS.
O tamanho máximo de um volume Ext2 é de 8 TiB.
O Ext2 foi projetado e implementado para corrigir as deficiências do Ext e prover um
sistema que respeitasse a semântica UNIX. A influência do UNIX pode ser vista, p.ex., na
utilização de grupos de blocos, que são análogos aos grupos de cilindros utilizados pelo FFS.
A versão original do FFS originou o que é hoje conhecido como UFS1 (Unix File System 1).
O bloco, que consiste num conjunto de setores (cada setor tem 512 bytes), é a menor
unidade de alocação para o Ext2. O tamanho pode ser de 1024, 2048 ou 4096 bytes e é
definido na formatação.
A partição EXT2 é o tipo usado para criar o sistema de arquivos Linux Native usado
para armazenar o sistema de arquivos EXT2 (após a formatação) e permitir o armazenamento
de dados.
4.1.2. Linux EXT3
A principal diferença entre o Ext2 e o Ext3 é a implementação do journaling, que
consiste em um registro (log ou journal) de transações cuja finalidade é recuperar o sistema
em caso de desligamento não programado.
Há três níveis de journaling disponíveis na implementação do Ext3:
Journal: os metadados e os dados (conteúdo) dos arquivos são escritos no
journal antes de serem de fato escritos no sistema de arquivos principal. Isso
aumenta a confiabilidade do sistema com uma perda de desempenho, devido
a necessidade de todos os dados serem escritos no disco duas vezes.
Writeback: os metadados são escritos no journal mas não o conteúdo dos
arquivos. Essa opção permite um melhor desempenho em relação ao modo
journal, porém introduz o risco de escrita fora de ordem onde, por exemplo,
arquivos que são apensados durante um crash podem ter adicionados a eles
trechos de lixo na próxima montagem.
Ordered: é como o writeback, mas força que a escrita do conteúdo dos
arquivos seja feita após a marcação de seus metadados como escritos no
journal. Esse é considerado um meio-termo aceitável entre confiabilidade e
performance, sendo, portanto, o nível padrão.
A vantagem de usar ext3 é que melhora a recuperação do sistema de arquivos caso
ocorra algum desligamento súbito do computador, por meio da gravação seqüencial dos dados
na área de metadados e acesso mhash da sua árvore de diretórios.
Embora o seu desempenho (velocidade) seja menos atrativo que o de outros sistemas
de arquivos (como ReiserFS e XFS), ele tem a importante vantagem de permitir que seja feita
a atualização direta a partir de um sistema com ext2, sem a necessidade de realizar um backup
e restaurar posteriormente os dados, bem como o menor consumo de processamento .
Enquanto em alguns contextos a falta de funções de sistemas de arquivos "modernos",
como alocação dinâmica de inodes e estruturas de dados em árvore, poderia ser considerada
uma desvantagem, em termos de "recuperabilidade" isso dá ao ext3 uma significante
vantagem sobre sistemas de arquivos que possuem-nas. Os metadados do sistema de arquivos
estão todos em locais fixos e bem conhecidos, e há certa redundância inerente à estrutura de
dados, que permite que sistemas ext2 e ext3 sejam recuperáveis no caso de uma corrupção de
dados significante, em que sistemas de arquivos em árvore não seriam recuperáveis.
4.1.3. Funcionalidades do Linux EXT3
A estrutura da partição ext3 é semelhante à da ext2, pelo que a migração de um
formato para o outro é simples. A adição do journaling é feita em um arquivo chamado
.journal que fica oculto pelo código ext3 na partição (desta forma ele não poderá ser apagado,
o que comprometeria o funcionamento do sistema). A estrutura idêntica da partição ext3 com
a ext2 torna mais fácil a manutenção do sistema, já que todas as ferramentas para recuperação
ext2 funcionarão sem problemas, sendo mesmo possível montar uma partição ext3 como se
fosse ext2.
Como o ext3 visa uma grande compatibilidade com o ext2, muitas das estruturas on-
disk são similares àquelas da ext2. Por causa disso, o ext3 não possui muitas das funções mais
recentes como alocação dinâmica de inodes e tamanhos de blocos variáveis (fragmentos ou
caudas).
Os sistemas de arquivos ext3 não podem ser checados enquanto são montados para
escrita. Um dump do sistema de arquivos feito enquanto ele está sendo montado para leitura e
escrita pode resultar em dados corrompidos dentro do arquivo de dump.
4.1.4. Desfragmentação do Linux EXT3
Não há uma ferramenta online de desfragmentação funcional em nível de sistema de
arquivos. Um desfragmentador offline da ext2, e2defrag, existe mas requer que um sistema
ext3 seja revertido previamente ao ext2. Mas, dependendo das funcionalidades ativadas no
sistema de arquivos, o e2defrag pode destruir dados; ele não sabe lidar com muitas das novas
funcionalidades do ext3.
4.1.5. Recuperação no Linux EXT3
Diferentemente do ext2, o ext3 zera os ponteiros de blocos nos inodes de arquivos
apagados. Ele faz isso para simplificar o acesso de leitura e escrita quando o journal está
sendo utilizado após uma montagem "suja". Isso, no entanto, previne efetivamente que os
arquivos sejam recuperados. O único recurso do usuário é fazer um "grep" no disco rígido
para buscar por dados que sejam sinalizadores de início/fim de arquivo. Isso provê uma
remoção de arquivos um pouco mais segura que em sistemas ext2, o que pode ser tanto uma
vantagem quanto uma desvantagem.
4.1.6. Compressão no Linux EXT3
Suporte a compressão transparente de dados (disponível como um patch extra-oficial
para ext2) não está disponível no ext3.
O ext3 tem um tamanho máximo para arquivos e para o sistema de arquivos inteiro.
Esses limites dependem do tamanho de bloco do sistema de arquivos; a tabela abaixo resume
esses limites:
Tabela com tamanho de blocos e tamanho de arquivos
O tamanho de bloco de 8 KiB está apenas disponível para arquiteturas (como a alpha)
que permitem paginação de 8 KiB.
4.1.7. Linux EXT4
Ext4 é a evolução do sistema de arquivos mais usados no Linux, o Ext3. De muitas
maneiras, Ext4 é uma profunda melhoria sobre o Ext3, sendo o Ext3, com muitas melhorias
frente o Ext2. No Ext3 foi principalmente a adição de Journaling sobre o Ext2, mas Ext4 teve
mudanças importantes na estrutura do sistema de arquivos destinado ao armazenamento de
dados. O resultado é um sistema de arquivos com um design aperfeiçoado, melhor
performance, confiável e com muitos recursos.
Um sistema de arquivos Ext3 existente, pode ser migrado para Ext4 com um
procedimento fácil, onde consiste a execução de um casal de comandos em modo “read-only”
(descrito na próxima seção). Por meio disto você melhora a performance, limites de
armazenamentos e recursos do sistema de arquivos corrente, com ou sem a “reformatação”
e/ou reinstalação do SO e softwares “environment”. Se você precisa das vantagens do Ext4
em um sistema em produção, você pode atualizar o sistema de arquivos. O processo é seguro
é não há riscos para seus dados (obviamente, fazer backup de dados críticos é recomendado,
pois você está atualizando seu sistema de arquivos). O Ext4 vai usar uma nova estrutura de
dados somente em novos dados, a estrutura antiga continuará intocada, é será possível para
leitura/escrita se for preciso. Desta forma, é claro, assim que uma vez convertido o sistema de
arquivos para Ext4, você não vai poder voltar para o Ext3 novamente.
4.1.8. Sistemas de arquivos ou arquivos grandes
Atualmente, Ext3 suporta 16TB de tamanho máximo no sistema de arquivos, e 2TB de
tamanho máximo de um arquivo. Ext4 adiciona 48-bit endereçados, obtendo assim 1EB de
tamanho máximo de sistema de arquivos e 16TB de tamanho máximo de arquivos. 1 EB =
1,048,576 TB (1 EB = 1024 PB, 1 PB = 1024 TB, 1 TB = 1024 GB).
4.1.9. Escalabilidade de subdiretórios
Atualmente a possibilidade máxima de número de subdiretórios contendo um único
diretório no Ext3 é 32.000. Ext4 quebra esse limite, e possibilita um número ilimitado de
subdiretórios.
4.1.10. Extends
Os tradicionais sistemas de arquivos derivados do Unix como o Ext3, utilizam um
esquema de mapeamento indireto de blocos para manter cada trilho do bloco usado
correspondente no dado de um arquivo. Isto é ineficiente para arquivos grandes,
especialmente um arquivo grande deletado e/ou operações “truncate”, porque o mapeamento
mantém uma entrada para muitos blocos únicos, e grandes arquivos tem muitos blocos. Os
sistemas de arquivos modernos usam uma abordagem diferente chamada “extends”. Um
extends é basicamente um punhado de blocos físicos continuo. Isto pode ser basicamente
definido: “Os dados no próximo bloco n”. Por exemplo, um arquivo de 100MB pode ser
alocado em um único extends deste tamanho, em vez de precisar da criação de um
mapeamento indireto para 25600 blocos (4KB por bloco). Arquivos grandes são divididos em
diversos extends. Extends melhora a performance e também ajuda a reduzir a fragmentação,
uma vez que incentiva o continuo “layouts” do disco.
4.1.11. Alocação multiblock
Quando o EXT3 precisa de nova escrita de dados no disco, há um alocador de blocos
que decide quais blocos livres deverá ser usado para a escrita do dado. Mas o alocador de
blocos do Ext3 somente alocar um bloco (4KB) em um momento. Esta forma que o sistema
precisa para escrever 100MB de dados mencionado anteriormente em outro ponto, será
necessário para chamar o alocador de blocos 25600 vezes (isto simplesmente para 100MB!).
Não só isto é ineficiente, como também não permite que o bloco de alocação utilize a política
de alocação porque ele não sabe como o total de muitos dados deve ter a alocação iniciada,
ele apenas conhece sobre um simples bloco. Ext4 usa “multiblock allocator” (mballoc), no
qual, aloca muitos blocos em uma simples chamada, em vez de um simples bloco por
chamada, evitando um monte de overhead. Isto melhora a performance, e é especialmente útil
com “alocação atrasada” e extends. Este novo recurso não afeta o formato do disco.
4.1.12. Atraso na alocação
Atraso na alocação é um recurso de performance (isto não muda o formato do disco)
encontrado em poucos sistemas de arquivos modernos, tais como o XFS, ZFS, btrfs ou Reiser
4, que constitui em um atraso na alocação de blocos tanto quando possível, contrário aos
tradicionais sistemas de arquivos (tais como o Ext3, Reiser3, etc) fazem: alocando os blocos
com a maior brevidade possível. Por exemplo, em um processo de escrita, o código do
sistema de arquivos irá atribuir imediatamente os blocos quando os dados forem coletados –
mesmo se os dados não estiverem sendo escritos agora para o disco, eles vão ser mantidos em
cache durante um tempo. Esta abordagem tem algumas desvantagens.Por exemplo, quando
um processo esta escrevendo continuamente em um arquivo, crescente, sucessivamente sendo
escritos atribuindo blocos para os dados, mas ele não sabe se o arquivo se manterá crescente.
Atrasando a alocação, por outro lado, não afetaria os blocos imediatamente quando o processo
de escrita, sim, ela atrasa a alocação dos blocos, enquanto o arquivo é mantido em cache, até
que ele esteja realmente indo para escrito no disco. Isto da ao bloco de alocação a capacidade
de alocar em situações em que sistemas antigos não poderia. Atraso na alocação trabalha
muito bem com as duas características anteriormente mencionadas, extents e alocação
multiblock, porque, em muitos casos um trabalho em que o arquivo é gravado para o último
disco que será atribuído em blocos extends, cuja alocação é feita com o mballoc. O
desempenho é muito melhor, e a fragmentação é muito melhorada em alguns workloads.
4.1.13. FSCK rápido
Fsck é uma operação muito lenta, especialmente o primeiro passo: checagem de todos
os inodes em um sistema de arquivos.
No Ext4, até o fim de cada grupo da tabela de inode estará armazenado uma lista de
inodes inutilizados ( com checksum, por segurança), assim o fsck não irá checar estes inodes.
O resultado final é que o tempo do fsck melhorou de 2 a 20 vezes, dependendo do número
usado de inodes. Deve-se notar que é o fsck, e não o Ext4, que irá montar a lista de inodes
inutilizados. Isso significa que você deve executar o fsck para obter a lista de inodes
inutilizados construída, e só na próxima execução do fsck será mais rápida. Há também uma
característica que ajuda a acelerar o fsck – “flexible block groups” – que também acelera as
operações em arquivos.
4.1.14. Journal checksumming
O Journal é mais utilizado na parte do disco, construindo os blocos mais propensos a
falhas de hardware. A recuperação de um journal corrompido pode levar a uma corrupção
massiva. Mas “journal checksumming” tem um bonus: ele permite a conversão e gravação em
duas-fases, sendo no Ext3 o journal em única fase, acelerando a operação no sistema de
arquivos para mais de 20% em alguns casos – assim a reabilitação e a performance são
melhoradas ao mesmo tempo.
4.1.15. Recursos relacionados aos inodes
Aumento de inodes: Ext3 suporta a configuração de tamanho de inode ( pelo
parâmetro -l do mkfs), mas o tamanho padrão de inode é 128 bytes. Ext4 tem
como padrão 256 bytes. Isto é necessário para acomodar algumas
características extras (como o timestamp em nano segundos ou
versonamento de inodes), e o espaço restante do inode será utilizado para
armazenar atributos extends suficientemente pequenos para caber nesse
espaço. Isto facilitará o acesso aos atributos com maior agilidade, e melhora
no desempenho das aplicações que usem alocação extend por um fator de 3-
7 vezes.
A reserva de inode consiste em alocar vários inodes quando um diretório é
criado, esperando que eles sejam utilizados no futuro. Melhorando a
performance, porque quando novos arquivos forem criados neste diretório,
eles serão capazes de utilizar os inodes reservados. Portanto a criação de um
arquivo, como também a ação de apagar o mesmo, será mais eficiente.
timestamps em nano segundos significa que áreas com “tempo modificado”
sejam capazes de usar resoluções em nano segundos em vez de segundo
como no Ext3.
4.1.16. Presistência na pré-alocação
As aplicações chamam o sistema de arquivos para pré-alocar o espaço, e o sistema de
arquivos aloca a quantida necessária de blocos e estrutura de dados, mas não há dados sobre o
assunto até que a aplicação realmente precisa para escrever os dados no futuro. Isto é o que
faz aplicações P2P quando “pré-aloca” o espaço necessário para uma transferência que irá
durar horas ou dias, mas muito mais eficiente quando implementado por um sistema de
arquivos do que por uma API genérica. Isto tem varios usos: em primeiro lugar, para evitar
aplicações (como aplicativos P2P) faze-lo propriamente e ineficientemente, mediante o
preenchimento de um arquivo com zeros. Segundo, para melhoria da fragmentação,
uma vez que os blocos serão alocados em um tempo, e continuamente se possível.
Terceiro, para assegurar que os pedidos tenham sempre o mesmo espaço solitado para a
necessidade, o que é importante para aplicações RT-ish, pois sem a pré-alocação o sistema de
arquivos poderá ficar cheio no meio de uma operação importante. Este recurso estará
disponível via libc posix_fallocate() interface.
4.1.17. ReiserFS
ReiserFS usa árvores balanceadas para tornar o processo de busca de arquivos,
informações sobre segurança e outros metadados mais eficientes. Para arquivos muito
pequenos, seus dados podem ser armazenados próximos aos metadados, então, ambos podem
ser recuperados com um pequeno movimento do mecanismo da "cabeça" de leitura do disco.
Essa propriedade vai contribuir para um melhor desempenho caso uma aplicação necessite
abrir muitos arquivos pequenos rapidamente.
No caso de um desligamento incorreto do sistema, o ReiserFS é capaz de recuperar a
consistência do sistema de arquivos em pouco tempo e a possibilidade de perda de pastas ou
partições é reduzida. Em compensação, os arquivos que eventualmente estiverem sendo
gravados no exato momento em que acabou a energia ficarão com seus dados corrompidos,
haverá acesso aos arquivos normalmente, mas o conteúdo estará truncado ou incompleto.
4.1.18. Desvantagens do ReiserFS
Uma desvantagem do ReiserFS é o seu consumo de CPU muito elevado. Utiliza no
mínimo 7 por cento da CPU, chegando a usar até 99 por cento, quando a actividade de disco é
elevada.
O futuro do ReiserFS é atualmente dado como incerto, em virtude da prisão em 10 de
Outubro de 2006 de Hans Reiser, seu criador, e sua condenação em 28 de Abril de 2008 pelo
assassinato de sua mulher no início de Setembro de 2006. Atualmente, devido à paralisação
das atividades da Namesys, o projeto ReiserFS está armazenado em kernel.org.
4.2. Gerenciamento de memória
Cada processo no Linux possui prioridades com relação à alocação de memória. O
Linux também possui uma característica de alocar determinados recursos dos processos que
foram executados para garantir que estes retornem de maneira mais eficiente quando estes
forem requisitados novamente. Caso a memória física (memória RAM) esteja totalmente
carregada, é iniciado um processo de operação com a memória virtual, a memória SWAP.
(Silva APUD Lima, 2007). Esse espaço da memória utilizado para armazenar estes recursos é
chamado de cache ou ainda prefetch.
Se verificarmos os níveis de memória durante a utilização do sistema, veremos que
mesmo com poucos programas abertos, a memória vai estar praticamente toda ocupada. Isso
ocorre pelo fato de que o Linux está alocando as páginas de memória livre para a alocação
desses recursos dos processos que são encerrados. Porém, devido a algoritmos complexos e
totalmente eficientes, além da memória SWAP (memória virtual), o sistema pode operar sem
lentidões.
À medida que mais processos vão sendo executados, e como estes tem preferência de
alocação na memória física, o Linux começa a jogar estes recursos alocados para a memória
SWAP. Os processos a serem lançados para a memória SWAP geralmente seguem o padrão
de latência do processo: os processos não utilizados a mais tempo são lançados para a
memória SWAP. Isso libera espaço na memória física, permitindo a alocação de mais
processos nessa memória. Essa memória SWAP é uma partição no disco rígido (partição
SWAP) dedicada exclusivamente para estes despejos de processos em caso de necessidade de
liberação de espaço na memória física. Essa partição é criada automaticamente na instalação
das distribuições Linux de maneira geral.
Com relação à alocação de páginas, a memória física é dividida através de um
algoritmo chamado buddy-heap. Este é responsável pela liberação de páginas de memória
física e também pela alocação de intervalos de página de acordo com o necessário. Este
algoritmo consegue alocar regiões “parceiras” de memória afim de aumentar a capacidade de
armazenar de maneira contínua os processos na memória física. Em caso da necessidade de
alocação de processos menores, os quais não necessitam ocupar toda uma região de memória,
o algoritmo pode dividir uma região em duas regiões parceiras, utilizando somente o espaço
necessário. Dessa maneira, a menor porção de alocação caracteriza-se como uma página de
memória.
Figura 10 - Esquema de gerenciamento de memória através do algoritmo buddy-heap.
Um outro alocador de memória concentra-se no kernel Linux. Este não utiliza
necessariamente os mecanismos tradicionais de alocação de memória. Estes caracterizam-se
por caches criados pelo próprio kernel, como o cache de buffers, o cache de páginas e o
sistema de gerenciamento de memória virtual.
A memória virtual no Linux é gerenciada de maneira ligeiramente diferente. As
páginas de memória virtual são criadas de acordo com a demanda, gerenciando memória
virtual de acordo com os conjuntos de regiões de memória (o que configura o espaço de
endereçamento) e conjuntos de páginas (uma visão física de cada espaço de endereçamento,
visão descrita nas tabelas de página do hardware). O kernel Linux pode criar espaços de
endereçamento virtual em duas situações: na execução de um novo programa através de uma
chamada ao sistema exec, no qual o processo recebe um espaço de endereçamento vazio, e
quando o processo é criado com chamada ao sistema fork, na qual é feita uma cópia integral
dos espaços de endereçamento virtual e os dois processos compartilham as mesmas páginas
de memória física.
Existe ainda a tática de transição de processos entre a memória física e a memória
virtual. Esse processo é conhecido como swapping. Os sistemas baseados em UNIX atuais
realizam a troca de páginas de processos, nunca realizando o swapping de processos inteiros.
Esse sistema de paginação é dividido em duas seções: o algoritmo de políticas, o qual
é responsável por decidir qual página deverá ser transferida para o disco e quando esta página
deve ser transferida; e o sistema de paginação, o qual transfere os dados novamente para a
memória física quando estes se tornam necessários novamente.
O Linux decide qual das páginas deve sofrer swapping através de um algoritmo
chamado LFU, ou Least Frequently Used. Nesse algoritmo, as páginas com menor frequência
de utilização são selecionadas para a realização da operação de swapping, com intuito de
realizar o menor número possível de trocas de páginas.
Figura 11 - Funcionamento básico do swapping
O kernel ainda reserva parte da memória virtual para seu uso interno. Esse espaço
dedicado é dividido em duas partes: uma estática, onde existem as referências das tabelas de
páginas; e outra dinâmica, de uso próprio do kernel.
4.3. Gerenciamento de processos
4.3.1. O conceito de processo
Em sistemas operacionais é conveniente diferenciar um programa e a sua execução. É
comum que um mesmo programa seja executado por vários usuários, ao mesmo tempo. Isto
ocorre com um editor de textos, por exemplo. Neste caso, todos os usuários utilizam uma
mesma cópia do código do editor de textos, porém cada execução trabalha sobre uma área de
variáveis privativa. Cada execução independente do editor de textos constitui um processo.
Um processo pode ser definido como "um programa em execução". O conceito de
processo é bastante abstrato, mas é essencial no estudo de sistemas operacionais.
Um programa é uma seqüência de instruções. É algo passivo dentro do sistema. Um programa
não altera o seu próprio estado. Por outro lado, o processo é um elemento ativo. Ele altera o
seu estado, à medida que executa um programa.
Para cada processo o sistema operacional mantém um registro descritor, que é um
pequeno bloco de memória que mantém informações sobre o processo (número único, estado,
valores dos registradores da UCP, etc.).
Como qualquer outro sistema de compartilhamento de tempo o Linux consegue dar a
impressão de execução simultânea dos processos, separando um espaço bastante curto de
tempo para cada um deles. Para ter sucesso nesta tarefa ele segue uma serie de regras que não
desperdiça tempo de hardware com operações desnecessárias e consegue escolher qual
processo deve ser executado naquele exato momento.
Quem faz essa escolha no kernel é o escalonador de processos, que em grande parte é
responsável pela produtividade e eficiência do sistema. Mais do que um simples mecanismo
de divisão de tempo, ele é responsável por uma política de tratamento dos processos que
permite os melhores resultados possíveis.
4.3.2. Os primeiros processos
Na fase de inicialização do Linux a função ``start_kernel'' é responsável por criar um
thread, este é o processo de número zero, o primeiro e o ascendente de todos os outros
processos. Depois de inicializar toda a estrutura de dados para este processo, esta mesma
função é responsável por chamar a função ``init'' que por sua vez utiliza a chamada de sistema
``execve'' para rodar o executável init, que será o processo número 1, mais conhecido como
init.
Podemos chamar de Deus e pai de todos os outros processos, é o segundo processo a
ser criado e um dos últimos a morrer. Seus filhos, vivem como nós seres humanos, eles
nascem, se desenvolvem, tem uma vida mais ou menos produtiva, podem ter inúmeros filhos
em poucos segundos e eventualmente morrem.
Existem alguns outros processos que também são criados pelo kernel durante a fase de
inicialização e destruídos assim que o sistema desliga. Outros são criados sob demanda, assim
que surge a necessidade deles são carregados.
4.3.3. Estados
Uma das coisas que o escalonador precisa ter ciência é em qual estado está cada
processo, na estrutura que armazena os dados de cada processo temos um array de possíveis
estados onde apenas uma das opções abaixo estará ativa.
TASK_RUNNING
Em execução ou aguardando para ser executado.
TASK_INTERRUPTIBLE
O processo está suspenso até que determinada condição se torne verdadeira.
TASK_UNINTERRUPTIBLE
Como o estado anterior, exceto pelo fato de que o seu estado não será modificado
quando receber um sinal. É importante para os processos que necessitam executar
determinada tarefa sem ser interrompido.
TASK_STOPPED
Execução do processo foi parada.
TASK_ZOMBIE
O processo está terminado, mas o processo pai ainda não executou uma chamada de
sistema para retornar informações sobre o processo morto - ``wait'', as informações não são
descartadas pois ainda podem ser utilizadas.
4.3.4. Limite de recursos
Por padrão o Linux limita os recursos que cada processo pode ter. Isto é, quanto de
recursos do sistema ele pode utilizar. Isso é uma proteção para que caso o usuário faça algo
errado, não prejudique a estabilidade do sistema. Esses limites são:
RLIMIT_AS
O tamanho máximo que um processo pode ter em bytes. O kernel checa esse valor
quando um processo utiliza a chamada de sistema ``malloc'' ou similar.
RLIMIT_CORE
Quando um processo é abortado, o kernel pode gerar um arquivo core contendo as
informações desse aborto. Este valor é utilizando para limitar o tamanho desse arquivo. Caso
o valor seja zero O, o arquivo não é criado.
RLIMIT_CPU
O tempo máximo em segundos que um processo pode ser executado. Caso esse limite
seja ultrapassado o kernel envia um sinal SIGXCPU para tentar pacificamente finalizar sua
execução, se isso não acontecer ele envia um SIGKILL e mata o processo.
RLIMIT_DATA
O tamanho máximo do heap ou memória de dados em bytes. O kernel checa esse valor
antes de expandir o heap de um processo.
RLIMIT_FSIZE
O tamanho máximo em bytes permitido para um arquivo. Se o processo tentar
aumentar o tamanho de um arquivo que ultrapasse esse valor, o kernel envia um SIGXFSZ.
RLIMIT_LOCKS
O número máximo de arquivos que um processo pode dar lock. Toda fez que o usuário
tenta dar lock em um arquivo o kernel checa esse valor.
RLIMIT_MEMLOCK
O tamanho máximo em bytes de memória que não permite swap. O kernel checa esse
valor toda vez são utilizadas as chamadas de sistema ``mlock'' ou ``mlockall''.
RLIMIT_NOFILE
O número máximo de descritores de arquivos abertos. Toda vez que um descritor for
aberto ou duplicado o kernel checa este valor.
RLIMIT_NPROC
O número máximo de processos que um usuário pode ter.
RLIMIT_RSS
A quantidade máxima de memória física que um processo pode ter.
RLIMIT_STACK
O tamanho máximo em bytes da stack. O kernel checa este valor antes de expandi-la.
4.3.5. Preemptivo
Os processos do Linux são preemptivos, isso significa que quando um processo entra
no estado TASK_RUNNING o kernel vai checar se existe alguma prioridade maior do que o
processo corrente. Caso exista, o processo corrente é interrompido e o que tem prioridade
maior começa a rodar.
Imagine a seguinte situação onde o usuário utiliza apenas dois processos. O editor de
textos Emacs para escrever o seu programa e ao mesmo tempo o gcc para compilar a versão
mais recente do programa Pogobol Light. Por ser um programa interativo o editor de textos
tem uma prioridade maior do que o compilador, mesmo assim ele ainda é suspenso diversas
vezes para que o compilador possa rodar também. O usuário digita algumas palavras e
imediatamente após cada tecla digitada o kernel suspende a execução do compilador para
poder processar o Emacs e assim o texto digitado aparecer na tela, isso acontece tão rápido
que torna-se imperceptível, então o Emacs é suspenso novamente para que o gcc possa voltar
a executar. Neste caso, quando dizemos que um processo foi suspenso, significa que ele
continua com o estado TASK_RUNNING, porém não mais utilizando o CPU.
4.3.6. Política de escalonamento
A prioridade de um processo no Linux está em constante alteração, o escalonador se
mantém informado sobre o que os processos estão fazendo e assim torna-se possível ajustar a
prioridade. Dessa maneira os processos que ficaram proibidos de utilizar o CPU por um longo
intervalo de tempo, tem sua prioridade incrementada automaticamente, contrariamente os
processos que passaram um longo período dentro do CPU são penalizados tendo sua
prioridade decrementada.
Quando tocamos no assunto escalonamento é importante notar que os processos são
classificados como da Forma E/S e Forma CPU. O primeiro faz uso extenso dos recursos de
entrada e saída, isso significa que grande parte do seu tempo é utilizado no aguardo da
conclusão das operações de Entrada e Saída, já o segundo são processos que necessitam de
um longo tempo dentro do CPU.
Uma classificação alternativa define três classes de processos:
Processos Interativos
Os processos que estão em constante interação com o usuário, sendo assim eles
perdem grande parte do tempo esperando uma atividade do usuário, como um clique do
mouse ou o aperto de uma tecla. Quando qualquer dessas ações for recebida o sistema precisa
responder de forma ágil suspendendo qualquer processo que estiver rodando e colocar o
processo interativo no CPU para processar a requisição solicitada pelo usuário, caso contrário
ele pode pensar que o sistema não está respondendo. Um bom tempo de resposta é em torno
de 50 e 150 ms.
Processos em Lote
Não necessitam de nenhuma interação do usuário e por isso muitas vezes rodam em
background. Como são processos de baixa prioridade, são freqüentemente penalizados pelo
escalonador. Programas de processamento em lote comuns são editores de texto,
compiladores e programas gráficos.
Processos em Tempo Real
Esses processos nunca devem ser bloqueados por processos de baixa prioridade,
precisam de um tempo de resposta super rápido e com uma variação bastante baixa. Alguns
aplicativos que fazem uso do tempo real são som, vídeo, controladores de robôs e
equipamentos que envolvem a segurança humana.
4.3.7. Algoritmo de Escalonamento
O algoritmo de escalonamento do Linux funciona dividindo o tempo do CPU em
fatias. Em uma única fatia cada processo tem um tempo especifico de duração que é
computada assim que essa fatia inicia. Geralmente processos diferentes tem tempos de
execução diferentes. Quando o tempo de execução de um processo termina ele é retirado do
CPU e outro processo que está rodando é colocado no seu lugar. Uma fatia termina quando
todos os processos esgotaram seu tempo reservado de execução, assim o escalonador é
responsável por calcular o tempo de execução para todos os processos e uma nova fatia inicia.
Para o Linux escolher qual processo deve rodar ele precisar escolher qual tem a
prioridade maior, existem dois tipos de prioridade:
Prioridade Estática
Definido pelo usuário para processos que necessitam de tempo real, os valores variam
de 1 até 99 que nunca são modificados pelo escalonador.
Prioridade Dinâmica
Esta é aplicada para os processos convencionais. A prioridade dinâmica dos processos
convencionais é sempre inferior aos processos com prioridade estática.
Se existir um processo com prioridade estática no estado TASK_RUNNING nenhum
processo dinâmico irá rodar até que ele pare de executar.
5 VANTAGENS E DESVANTAGENS DO LINUX
5.1 Vantagens
Custos muito baixos ou até nulos
Por serem baseadas em software livre, as distribuições Linux podem ser encontradas
até gratuitamente. Algumas distribuições, como o Ubuntu, disponibilizam em seus sites
oficiais links de download das imagens dos CDs de instalação ou até mesmo disponibilizam
um formulário onde você pode solicitar a entrega de mídias de instalação através do correio.
Versões mais “elaboradas”, como aquelas dedicadas exclusivamente a servidores, podem
apresentar um pequeno custo por causa da licença, mas esse custo ainda é muito menor do que
licenças de outros sistemas operacionais, como os sistemas da família Windows. Ainda há o
fato de que, por ser software livre, os usuários podem modificar o código-fonte do sistema
para atender alguma necessidade específica, recompilar tudo e distribuir normalmente.
Maior estabilidade e segurança
Os sistemas Linux são mais estáveis, pois conseguem gerenciar de maneira mais eficiente
os recursos de hardware. Isso permite que até máquinas mais antigas possam rodar versões
mais novas das distribuições. Além disso, são mais seguros, pois o número de pragas virtuais
para sistemas Linux ainda é muito reduzido, além de que códigos que modifiquem qualquer
parte do sistema sempre são interceptados com a autenticação obrigatória o superusuário
(root). Esse recurso inclusive começou a ser incorporado de maneira similar a partir do
Windows Vista na família Windows, através do Controle de Conta de Usuário.
Comunidade extensa e ativa
A comunidade Linux é muito ativa. Manifesta-se através de fóruns, listas de discussão
e outros meios através da internet, meios de fácil acesso. Isso garante suporte quando
necessário, inclusive em português. Você pode obter auxílio para problemas bem básicos
como para problemas mais complexos.
5.2 Desvantagens
Incompatibilidade com alguns equipamentos
Alguns fabricantes de equipamentos não escrevem drivers para o sistema Linux para
seus equipamentos, como é o caso de algumas impressoras da HP. Existem alternativas para
estes casos, porém geralmente são tortuosas de serem implementadas e podem desencorajar os
usuários a utilizarem as distribuições Linux.
Incompatibilidade com alguns formatos de arquivos
Alguns formatos de arquivos, principalmente os proprietários da Microsoft, não são
executados com toda a fidelidade, como é o caso do formato de vídeo WMV. Existem plug-
ins para executá-los, mas estes não acabam oferecendo a mesma qualidade que se o arquivo
estivesse sendo executado no Windows Media Player.
O Linux ainda peca na facilidade de uso
Mesmo com o esforço de algumas distribuições como o Ubuntu, o Linux não consegue
oferecer a mesma facilidade de uso que o Windows. Isso talvez se deva mais a um fator
cultural, mas o fato é que se você entregar um computador com Linux pra alguém que
trabalha com Windows, este certamente sentirá um pouco de dificuldade, o que não acontece
geralmente ao contrário. Muitas coisas ainda são mais fáceis de serem executadas via
terminal, porém as pessoas geralmente “temem” aquela tela preta com um monte de
comandos em branco.
6 CONCLUSÕES
Concluímos que desde o manifesto inicial feito por Linus Torvalds até hoje, o Linux
tem evoluído com muita velocidade e profissionalismo, ao contrario do que muitos apostavam
por se tratar de um software livre.
Suas funcionalidades plug and play, drivers compativeis e aplicativos cresceram de tal
forma que pouquíssima coisa é incompatível ou não funciona bem no Linux.
Suas diversas distribuições tiveram investimentos pesados oriundos de empresas como
Siemens, Sun, Oracle e outras que fomentaram seu desenvolvimento e hoje, é uma plataforma
atualizada, otimizada e funcional tanto para desktops quanto para servidores. Linux de fato
veio para ficar e sua difusão está cada vez mais forte devido principalmente os órgãos
governamentais que optaram por utilizá-lo como forma de fugir do monopólio Microsoft.
Com o advento da computação nas núvens, a discussão e o uso do Linux ganha novo
folego e talvez, a compatibilidade e independencia necessária para talvez, assumir a primeira
posição no mercado
7 BIBLIOGRAFIA
Gonçalves, A., Luvizotto, D., Nascimento, H., Santos, L., Martins, L. Sistemas Linux.
Universidade Estadual de Londrina, Londrina, 2007. Disponível eletronicamente em
<http://www.dca.fee.unicamp.br/~andreric/arquivos/sistemas_linux.pdf>. Acessado em 19 e
20 de maio de 2011;
Júnior, J., Alvarez, D. Gerenciamento de memória no Linux. Instituto Tecnológico
da Aeronáutica (ITA). São José dos Campos. Disponível em
<http://ces33.wikidot.com/gerenciamento-de-memoria:jose-gerardo-e-diego-alvarez>.
Acessado em 19 de maio de 2011;
UOL Tecnologia. Linux: vantagens e desvantagens do sistema. Disponível em
<http://tecnologia.uol.com.br/especiais/ultnot/2005/08/18/ult2888u81.jhtm>. Acesso em 20
de maio de 2011.
Brasil Escola. História do Linux. Disponível em <
http://www.brasilescola.com/informatica/historia-do-linux.htm>. Acessado em 18 de maio de
2011.
Kernel.org. The Linux Kernel Archives. Disponível em < http://www.kernel.org/>.
Acessado em 19 de maio de 2011.
Wikipédia. Linux. Disponível em <http://en.wikipedia.org/wiki/Linux>. Acessado em
18 de maio de 2011.
Endian.com. Endian. Disponível em < http://www.endian.com/us/>. Acessado em 19
de maio de 2011.
Damnsmalllinux.org. Damn Small Linux. Disponível em <
http://www.damnsmalllinux.org/>. Acessado em 19 de maio de 2011.
4Security. 4Security. Disponível em < http://www.4security.com.br/>. Acessado em
19 de maio de 2011.
Kernelnewbies.org. EXT4. Disponível em <http://kernelnewbies.org>. Acessado em
19 de maio de 2011.