História do Linux, Trabalhos de Informática

Baixe História do Linux e outras Trabalhos em PDF para Informática, somente na Docsity!

Instituto Federal de Educação, Ciência e Tecnologia do Sudeste de Minas

Campus Juiz de Fora

LINUX

Introdução aos Sistemas Operacionais – Professor Eduardo

Sumário

• Capa....................................................................................................................
• Sumário................................................................................................................
• Introdução
• Histórico
• Estrutura do Sistema Operacional......................................................................
• Tipo de Sistema Operacional
• Estrutura de diretórios
• Vantagens do Linux
• Processos...........................................................................................................
  • Primeiros Processos
• Estados
• Limite de Recursos.............................................................................................
• Preemptivo
• Política de Escalonamento
  • Processos Interativos
  • Processos em Lote
  • Processos em Tempo Real
• Algoritmo de Escalonamento............................................................................
• Prioridade Estática
  • Prioridade Dinâmica
• Gerência de memória
• Gerência de memória virtual
  • Paginação, Tabelas de Páginas[...]...............................................................
  • Aplicação da Memória Virtual no Linux
• Sistema de arquivos
  • Ext2
  • Ext3
  • ReiserFS
  • XFS
  • VFAT
• Exemplo/Particularidade
• Bibliografia........................................................................................................
• Nome dos Alunos...............................................................................................

No dia 5 de outubro de 1991 Linus Torvalds anunciou a primeira versão "oficial" do núcleo Linux, versão 0.02. Desde então muitos programadores têm respondido ao seu chamado, e têm ajudado a fazer do Linux o sistema operacional que é hoje. No início era utilizado por programadores ou só por quem tinha conhecimentos, usavam linhas de comando. Hoje isso mudou, existem diversas empresas que criam os ambientes gráficos, as distribuições cada vez mais amigáveis de forma que uma pessoa com poucos conhecimentos consegue usar o Linux. Hoje o Linux é um sistema estável e consegue reconhecer muitos periféricos sem a necessidade de se instalar os drivers de som, vídeo, modem, rede, entre outros.

Estrutura do Sistema Operacional

O Linux é um núcleo monolítico: as funções do núcleo (escalonamento de processos, gerenciamento de memória, operações de entrada/saída, acesso ao sistema de arquivos) são executadas no espaço de núcleo. Uma característica do núcleo Linux é que algumas das funções (drivers de dispositivos, suporte à rede, sistema de arquivos, por exemplo) podem ser compiladas e executadas como módulos (em inglês: LKM - loadable kernel modules ), que são bibliotecas compiladas separadamente da parte principal do núcleo e podem ser carregadas e descarregadas após o núcleo estra em execução.

Logo que Linus Torvalds passou a disponibilizar o Linux, ou seja, na sua versão 0.01, já havia suporte ao disco rígido, tela, teclado e portas seriais, o sistema de arquivos adotava o mesmo layout do Minix (embora não houvesse código do Minix no Linux), havia extensos trechos em assembly, e ela já era capaz de rodar o bash e o gcc.

O próprio usuário deveria procurar os programas que dessem funcionalidade ao seu sistema, compilá-los e configurá-los. Talvez por isso, o Linux tenha carregado consigo a etiqueta de sistema operativo apenas para técnicos. Foi neste ambiente que surgiu a MCC Interim Linux , do Manchester Computer Centre , a primeira distribuição Linux, desenvolvida por Owen Le Blanc da Universidade de Manchester, capaz de ser instalada independentemente em um computador. Foi uma primeira tentativa de facilitar a instalação do Linux.

Desde o começo, o núcleo Linux incluía um sistema básico para chamadas do sistema e acesso aos dispositivos do computador. O núcleo de um sistema operativo define entre várias operações, o gerenciamento da memória, de processos, dos dispositivos físicos no computador e é uma parte essencial de qualquer sistema operacional utilizável. Contudo para um sistema operacional adquirir funcionalidade são necessários também vários outros aplicativos que determinam funções específicas que aquele sistema será capaz de desenvolver, os aplicativos existentes em um sistema operacional com a única exceção do núcleo são determinados pelo usuário do computador, como por exemplo: interpretadores de comandos, gerenciadores de janelas, que oferecem respectivamente uma interface para o usuário do computador, CLI ou GUI, e outros aplicativos como editores de texto, editores de imagem, tocadores de som, e, mas não necessariamente, compiladores.

A maioria dos sistemas inclui ferramentas e utilitários baseados no BSD e tipicamente usam XFree86 ou X.Org para oferecer a funcionalidade do sistemas de janelas X — interface gráfica. Assim como também oferecem ferramentas desenvolvidas pelo projeto GNU.

No momento do desenvolvimento do Linux, vários aplicativos já vinham sendo reunidos pelo Projeto GNU da Free Software Foundation (‘Fundação Software Livre’), que embarcara em um subprojeto que ainda continua para obter um núcleo, o GNU Hurd. Porém devido a várias complicações no projeto GNU e demora em desenvolver o Hurd, Stallman acabou adotando o núcleo Linux como base para distribuir os programas do projeto GNU. Não obstante diversas pessoas e instituições tiveram a mesma ideia e assim várias distribuições começaram a surgir baseadas no núcleo desenvolvido inicialmente por Linus.

Tipo de Sistema Operacional

O Linux é multi-tarefa(capacidade que o sistema tem de executar várias tarefas de uma só vez, dividindo assim o uso da memória) e multi-usuário(capacidade do sistema lhe dar com várias pessoas ou usuários, cada um com suas preferências, cada um com seus arquivos, suas permissões e assim por diante).

Estrutura de diretórios

A estrutura de diretórios do Linux não lembra em nada o que temos no Windows. No Windows temos os arquivos do sistema concentrados nas pastas Windows e Arquivos de programas, e você pode criar e organizar suas pastas da forma que quiser.

No Linux é basicamente o contrário, o diretório raiz está tomado pelas pastas do sistema e espera-se que você armazene seus arquivos pessoais dentro da sua pasta no diretório /home.

Os discos e partições não aparecem necessariamente como unidades diferentes, como o C:, D:, E: do Windows. Tudo faz parte de um único diretório, chamado diretório raiz ou simplesmente "/".

Dentro deste diretório temos não apenas todos arquivos e as partições de disco, mas também o CD-ROM, drive de disquete e outros dispositivos, formando a estrutura abaixo:

/ => O diretório raiz, representado pela "/", é específico de cada máquina. Pode ficar tanto em um disco físico quanto na memória da máquina ou em uma unidade de rede. É o diretório principal, que contém todos os arquivos e diretórios do sistema.

/bin => Arquivos binários de comandos essenciais do sistema.

Processos

Como qualquer 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.

O que decide 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.

Primeiros Processos

Durante a 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. “Após 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.

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.

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 série 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.

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 vez que o usuário tenta dar lock em um arquivo o kernel checa esse valor.

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 frequentemente 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.

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 têm 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.

Gerência de memória

No Linux a memória funciona da seguinte maneira, processos que estão em execução têm prioridade na memória, quando termina um processo e se tiver espaço na memória, ficam resíduos desse processo na memória para uma futura volta desse processo ser mais rápida. Caso essa memória RAM esteja lotada com processos que estão em execução, aí começa a utilização da memória SWAP.

Cada processo do Linux, em uma máquina de 32 bits, dispõe de 3GB de espaço de endereçamento virtual para si próprio, com 1GB restante reservado para suas tabelas de páginas e outros dados do núcleo. O 1GB do núcleo não é visível quando o processo executa no modo usuário, mas torna-se acessível quando o processo faz uma chamada ao núcleo. O espaço de endereçamento é gerado quando o processo é criado e sobrescrito em uma chamada ao sistema exec.

O espaço de endereçamento virtual é dividido em áreas ou regiões organizadas em páginas. Contíguas e homogêneas. Isso quer dizer que cada área consiste de uma série de páginas consecutivas com proteção e propriedades de paginação idênticas. O segmento de código e os arquivos mapeados são exemplos de áreas. Pode haver vazios no espaço de endereçamento virtual entre essas áreas. Qualquer referência à memória para um vazio resulta em uma falta de página fatal. O tamanho de página é fixo.

O Linux usa um esquema de paginação de três níveis. Embora tenha sido utilizado no processador Alpha, esse esquema também é empregado de maneira modificada em todas as arquiteturas. Cada endereço virtual é quebrado em até quatros campos. O campo diretório é usado como índice do diretório global, sendo que existe um privado para cada processo. O valor encontrado é um ponteiro para um dos diretórios intermediários de página, o qual é indexado por um campo do endereço virtual. A entrada selecionada aponta para a tabela de página final, a indexada pelo campo página do endereço virtual. A entrada encontrada aponta para a página requisitada. No Pentium, que usa paginação em dois níveis, cada diretório intermediário de página tem somente uma entrada, de modo que, efetivamente, a entrada do diretório global é quem escolhe a tabela de página a usar.

gerar ao serem executados por do uso de indexação, de registradores-base, registradores de segmento ou outras técnicas. Esses endereços são denominados endereços virtuais e constituem o espaço de endereçamento virtual, existe uma exceção para computadores com pouca memória e seus endereços virtuais são iguais aos físicos, em computadores com memória virtual, os endereços não vão direto para o barramento e sim para a MMU (Memory Management Unit – unidade de gerenciamento de memória), que mapeia endereços virtuais em endereços físicos.

O espaço de endereços virtuais é dividido em unidades chamadas páginas e o espaço de memória física é dividido em unidades chamadas quadros de página, de mesmo tamanho das páginas. A MMU tem uma tabela que indica para cada página, qual o quadro de página que corresponde à mesma. Se o processador tenta acessar o endereço 0, a MMU verifica que isto corresponde ao primeiro endereço da primeira página, verifica então que essa primeira página está alocada no terceiro quadro de página. Converte então esse endereço para 8192 (decimal) e envia o endereço convertido para a memória (nem a memória e nem o processador precisam ficar sabendo da existência de paginação). Esse processo pode ser melhor analisado observando a Figura 1.

Figura 1 – Processo de gerenciamento de memória, utilizando o método de memória virtual.

O modelo acima descreve o tratamento mais simples seria uma longa tabela de página com uma entrada por página (Essas entradas são conhecidas como entradas de tabela de páginas ou PTE - page table entries). No entanto, esta solução resultaria em uma tabela de

página que seria muito grande para ser encaixada na MMU, dado que tem que ser na memória. A solução, portanto são tabelas de páginas de multiníveis. Desse modo, à medida que o tamanho dos processos crescem, novas páginas são alocadas e, quando o são, a parte da memória associada à tabela de página é preenchida. Esse método de gestão de memória que permite que o espaço de armazenamento seja não contíguo.

A paginação é suportada por hardware ou por uma combinação do hardware com o software, dividindo-se a memória física em blocos de tamanho fixo, chamados frames, cujo tamanho é uma potência de 2. A memória lógica é dividida em blocos do mesmo tamanho, as chamadas páginas.

Um endereço virtual é 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 KB (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 – Tabela de páginas de multiníveis.

Outro ponto importante é que a tradução de endereços virtuais para físicos tem de ser rápida. Isso requer que a tradução seja feita, tanto quanto possível no hardware. Como não é

espaço de endereçamento é gerado quando o processo é criado e sobrescrito em uma chamada ao sistema.

A paginação fornece uma forma de se conseguir grandes espaços de endereçamento lineares em uma quantidade finita de memória física.

Sistema de arquivos

A lista de sistemas de arquivos suportados pelo Linux é muito grande, porém citaremos os mais comuns.

Atualmente, uma importante característica dos atuais sistemas de arquivos é o "journaling". Sistemas de arquivos que possuem essa característica são preferidos em detrimento aos que não possuem.

Journaling é um recurso que permite recuperar um sistema após um desastre no disco (ex.: quando um disco está sujo) em uma velocidade muito maior que nos sistemas de arquivos sem journaling.

Segue abaixo uma breve descrição sobre os sistemas de arquivos mais comuns disponíveis para o Linux:

Ext

O sistema de arquivos ext2 é conhecido como "Second Extended FileSystem". Foi desenvolvido para ser mais "eficiente" que o sistema de arquivos "Minix", seu antecessor.

O Minix era muito utilizado nas primeiras versões do Linux, e foi utilizado por muitos anos.

O sistema de arquivos ext2 não possui journaling e foi substituído pelo ext3.

Ext

O sistema de arquivos ext3 é uma versão do ext2 com suporte a journaling. Portanto, o ext tem as mesmas características do ext2, mas com suporte journaling.

Essa característica foi uma evolução e tornou o ext3 um sistema de arquivos muito estável e robusto.

Como no ext3 só foi adicionado o suporte a journaling, podemos converter um sistema de arquivos ext2 para ext3, adicionado suporte a journaling, e também podemos converter um sistema de arquivos ext3 para ext2, removendo o suporte a journaling.

ReiserFS

O sistema de arquivos ext3 é uma versão do ext2 com suporte a journaling. Portanto, o ext3 tem as mesmas características do ext2, mas com suporte journaling.

Essa característica foi uma evolução e tornou o ext3 um sistema de arquivos muito estável e robusto.

Como no ext3 só foi adicionado o suporte a journaling, podemos converter um sistema de arquivos ext2 para ext3, adicionado suporte a journaling, e também podemos converter um sistema de arquivos ext3 para ext2, removendo o suporte a journaling.

XFS

O sistema de arquivos ext3 é uma versão do ext2 com suporte a journaling. Portanto, o ext3 tem as mesmas características do ext2, mas com suporte journaling.

Essa característica foi uma evolução e tornou o ext3 um sistema de arquivos muito estável e robusto.

Como no ext3 só foi adicionado o suporte a journaling, podemos converter um sistema de arquivos ext2 para ext3, adicionado suporte a journaling, e também podemos converter um sistema de arquivos ext3 para ext2, removendo o suporte a journaling.

VFAT

O sistema de arquivos VFAT é também conhecido como FAT32 (MS Windows).

O sistema de arquivos VFAT não possui suporte a journaling. É utilizado normalmente para transferir dados entre sistemas MS Windows e o Linux instalados no mesmo disco, pois pode ser lido e escrito por ambos os sistemas operacionais.

O sistema de arquivos VFAT está longe de ser um sistema de arquivos utilizado para Sistemas Linux, exceto para compartilhamento/compatibilidade entre o MS Windows e Linux.

Se você utilizar VFAT no Linux, esteja certo de perder alguns atributos, tais como: permissão de execução, links simbólicos, entre outras coisas.

Ambos os sistemas de arquivos ext3 e ReiserFS são maduros o bastante para serem utilizados como padrão no Linux. Esses dois são os mais utilizados pelas distribuições Linux.

Nome dos Alunos

Fernando Ferreira Passe

Flávia Apolinário Camilo

Renata Matias

Felipe Acácio de Paiva