OS

ESCOLA ESTADUAL DE EDUCAÇÃO PROFISSIONAL
JOÃO DE CÉSARO
SISTEMAS OPERACIONAIS
PROFESSOR: FELIPE AMARO GRADIN
2
SUMÁRIO
1. Conceitos Básicos.................................................................................................................... 3
1.1 Sistema Operacional: o elo entre hardware e software! ................................................. 3
2. Histórico e Evolução dos Sistemas Operacionais ................................................................. 5
2.1 A Primeira Geração (1945-1955): Válvulas e Painéis com Plugs .................................... 5
2.2 A Segunda Geração (1955 - 1965): Transistores e Sistemas Batch ............................... 5
2.3 A Terceira Geração (1965 - 1980): Circuitos Integrados e Multiprogramação............... 5
2.4 A Quarta Geração (1980-...): Computadores Pessoais.................................................... 7
3. Tipos de Sistemas Operacionais ........................................................................................... 10
3.1 Sistemas Monotarefa ....................................................................................................... 10
3.2 Sistemas Multitarefa ........................................................................................................ 10
3.2.1 Monousuário............................................................................................................ 10
3.2.2 Multiusuário............................................................................................................. 11
3.3 Sistemas Desktop ............................................................................................................ 11
3.4 Sistemas Embutidos........................................................................................................ 11
3.5 Sistemas em Batch (Lote) ............................................................................................... 11
3.6 Sistemas de Tempo Real ................................................................................................. 12
3.7 Sistemas de Rede ............................................................................................................ 12
3.8 Sistemas Servidores........................................................................................................ 12
3.9 Sistemas Distribuídos ..................................................................................................... 12
3.10 Sistemas Paralelos ou Multiprocessados .................................................................... 12
4. Arquitetura do Sistema Operacional ..................................................................................... 13
4.1 Núcleo.............................................................................................................................. 13
4.2 Drivers .............................................................................................................................. 13
4.3 Código de Inicialização.................................................................................................... 13
4.4 Programas Utilitários....................................................................................................... 13
5. O Sistema Operacional Como um Gerenciador de Recursos.............................................. 15
5.1 Gerência de Processos.................................................................................................... 15
5.1.1 Estados de um Processo........................................................................................ 16
5.1.2 Criação e Término de Processos........................................................................... 16
5.1.3 Escalonamento de Processos................................................................................ 17
5.1.3.1 Algoritmos de Escalonamento ................................................................... 17
5.1.4 Hierarquias de Processos ...................................................................................... 18
5.1.5 Comunicação Entre Processos.............................................................................. 18
5.1.5.1 Condições de Disputa................................................................................. 18
5.1.5.2 Seções (ou regiões) Críticas....................................................................... 18
5.1.5.3 Deadlock ...................................................................................................... 19
6. Gerência de Memórias............................................................................................................ 20
6.1 Alocação Contígua Simples ............................................................................................ 20
6.2 Técnica de Overlay .......................................................................................................... 21
6.3 Alocação Particionada..................................................................................................... 22
6.3.1 Alocação Particionada Estática ............................................................................. 22
6.3.2 Alocação Particionada Dinâmica ........................................................................... 25
6.4 Swapping......................................................................................................................... 27
7. Gerência de Dispositivos de Entrada e Saída....................................................................... 29
7.1 Princípios Básicos de Hardware de Entrada e Saída .................................................... 29
7.1.1 Dispositivos de Entrada e Saída ............................................................................ 29
7.1.2 Interface, Registradores e Controladores ............................................................. 29
7.2 Princípios Básicos de Software de Entrada e Saída ..................................................... 30
7.2.1 Drivers...................................................................................................................... 30
8. Gerência de Disco................................................................................................................... 31
8.1 Arquivos ........................................................................................................................... 31
8.2 Diretórios......................................................................................................................... 33
8.2.1 Diretórios Lineares.................................................................................................. 33
8.2 Diretórios Hierárquicos ................................................................................................... 34
Referências Bibliográficas......................................................................................................... 35
3
1. Conceitos Básicos
Atualmente grande parte da população já ouviu falar sobre Sistemas Operacionais,
principalmente nos sistemas da Microsoft e de seus rivais Linux e McOS. Mas também é
perceptível que muitos nem ao menos sabem o que ele exatamente faz no mundo tecnológico. O
conceito Sistema Operacional tornou-se um pouco obscuro com o passar dos anos, pois muitos
tiveram uma educação digital de mão única. Digo isto pelo fato de que as pessoas estão
acostumadas a lidarem apenas com os objetivos cruciais, no que diz respeito à utilização do
computador. Dentre eles, podemos citar a elaboração de textos, planilhas, gravação básica de
arquivos, comunicação online, etc. talvez visando facilitar o ensino muitos educadores acabam
não aprofundando o assunto relacionado à plataforma utilizada, no caso, o sistema Operacional.
1
.1 Sistema Operacional: o elo entre hardware e software!
Antes de abordar o que é um Sistema Operacional é interessante analisar a idéia que se
tem sobre o sistema de computação. O sistema de computação pode ser considerado de forma
geral o seguinte conjunto de itens: Hardwares (conjunto de componentes eletrônicos, circuitos
integrados e placas) e Softwares (conjunto de instruções lógicas utilizados sobre um hardware
para o processamento de dados). Para que a parte física do computador possa funcionar
adequadamente, faz-se necessário um conjunto de instruções que possam ser entendidas por
estes dispositivos. Este conjunto de instruções é denominado de software ou programa.
Após analisar o que é um sistema de computação é possível concluir que um computador
sem Software não passa de um aglomerado de componentes eletrônicos, circuitos integrados,
placas e estruturas metálicas.
O software pode ser subdividido de um modo geral em:
1. Programas Aplicativos: São programas, desenvolvidos por usuários ou empresas
especializadas, voltados para usuários. Eles permitem realizar tarefas comerciais, pessoais e de
entretenimento. Ex: programas de folha de pagamento, jogos, programas de controle de estoque,
Word, Excel, Internet Explorer, gerenciador de banco de dados, gerenciador de redes, MSN, etc.
2. Programas Utilitários: São programas que atuam sobre o sistema operacional para
melhorar o desempenho dos mesmos ou lhes incluir novos recursos, ampliando os recursos do
sistema, facilitando o uso e auxiliando a manutenção de programas. Eles fornecem um
complemento para tarefas do Sistema Operacional. Ex: editores, compiladores, ScanDisk,
desfragmentador de disco, backup, antivírus, compactador etc.
Nesta apostila, iremos estudar o software básico, que também é conhecido como sistema
operacional. Já que este tipo de programa é essencial ao funcionamento do computador, sem
dúvidas, merece um capítulo especial!
Afinal de contas, o que é um sistema operacional?
Como vimos anteriormente um sistema de computação possui, normalmente, diversos
componentes como terminais, impressoras, discos, fitas, etc. Quando utilizamos estes dispositivos
não nos preocupamos com a maneira como são realizadas estas comunicações e os inúmeros
detalhes envolvidos. Uma operação aparentemente simples como ler um cd exige um conjunto
muito grande de rotinas especificas, como por exemplo, converter um endereço lógico em físico,
posicionar a cabeça na trilha correta, esperar pelo setor correto passar, etc. O sistema operacional
serve então como uma interface entre o usuário e os recursos do sistema, tornando esta
comunicação transparente.
Sistema Operacional pode ser conceituado como o conjunto de programas (instruções
lógicas) existentes entre os equipamentos (hardwares) e os programas aplicativos que realizam as
tarefas comuns para os usuários. Ele é o item fundamental na qualidade do sistema
computacional, pois é através do Sistema Operacional que é possível executar um programa,
realizar acesso a periféricos, acessar e manipular arquivos, etc. Em outras palavras podemos
4
defini-lo com conjunto de instruções (programas) que controla todos os recursos do computador e
fornece a base sobre a qual, outros programas aplicativos serão escritos.
Exemplos de sistema operacional: Windows, MS-DOS, Unix, Linux, Mac/OS.
Porque os sistemas operacionais foram criados?
Basicamente, o sistema operacional foi criado pelos seguintes motivos: o primeiro deles
era o de fornecer ao programador/usuário uma forma mais conveniente para a operação do
computador, ou seja, fornecer uma interface amigável aos usuários do computador.
Tecnicamente falando ele esconde complexidade e detalhes internos inerentes à manipulação e
controle dos componentes de hardware. Reduz tempo de preparação de um programa. Permite a
execução do mesmo programa em ambientes diferentes. Permite várias aplicações trabalharem
simultaneamente e controla a interação entre: Usuários e hardware bem como entre os diversos
usuários.
Ainda dentro de suas diversas funções podemos citar: Gerenciar programas, discos e
arquivos; Distribuir a memória; Controlar os dispositivos de entrada e saída; Permitir acesso ao
sistema (logon); Iniciar programas; Compartilhar tempo de CPU; Etc.
Diante de tal definição podemos concluir que o sistema operacional é um elo de ligação
entre o hardware e o software possibilitando ao usuário ou usuários uma melhor utilização do
computador como é exemplificado no diagrama abaixo:
Usuáriio 1 Usuáriio 2 Usuáriio 3 Usuáriio n
Programas de Aplliicação e Uttiilliittáriios
Siisttema Operaciionall
Hardware
5
2. Histórico e Evolução dos Sistemas Operacionais
Os sistemas operacionais vêm passando por um processo gradual de evolução. Como a
história dos sistemas operacionais é bastante ligada à arquitetura de computadores sobre a qual
eles são executados, veremos as sucessivas gerações de computadores para entendermos as
primeiras versões de sistemas operacionais.
2.1 A Primeira Geração (1945-1955): Válvulas e Painéis com Plugs
Pouco progresso se teve na construção de computadores digitais até a Segunda Guerra
Mundial. Em torno de 1940 obteve-se sucesso na construção de máquinas calculadoras usando
válvulas. Essas máquinas eram enormes, ocupando salas completas, com dezenas de milhares
de válvulas. Toda a programação era feita em linguagem de máquina, sempre se conectando fios
com plugs em painéis para controlar as funções básicas da máquina. Nem se ouvia falar em
sistemas operacionais. O modo usual de operação consistia no programador elaborar o programa
numa folha e então ir à sala da máquina, inserir os plugs nos painéis do computador.
Por volta dos anos 50, essa rotina teve uma pequena evolução com a introdução de cartões
perfurados. Era possível, a partir de então, se escrever programas em cartões e lê-los, em vez do
uso de plugs em painéis.
2.2 A Segunda Geração (1955 - 1965): Transistores e Sistemas Batch
A introdução do transistor em meados dos anos 50 mudou o quadro radicalmente. Os
computadores tornaram-se bastante confiáveis para que pudessem ser produzidos e vendidos
comercialmente na expectativa de que eles continuassem a funcionar por bastante tempo para
realizar algumas tarefas usuais. Apenas grandes companhias, agências governamentais, ou
universidades, dispunham de condições para pagar o preço por essas máquinas. Para rodar um
job (um programa ou um conjunto de programas), primeiro o programador escrevia o programa no
papel (em FORTRAN ou linguagem Assembly), e então o perfurava em cartões. Então, ele levava
o "deck" de cartões à sala de recepção e o entregava a um dos operadores.
Devido ao alto custo do equipamento a solução geralmente adotada era o sistema em
"batch". Colecionava-se uma bandeja completa de jobs que então eram lidos para uma fita
magnética usando um computador pequeno e relativamente barato que era muito bom na leitura
de cartões, na cópia de fitas e na impressão da saída e outros computadores, máquinas mais
caras, eram usados para a computação real.
Muitos computadores da segunda geração foram usados principalmente para cálculos
científicos e de engenharia, tais como em solução de equações diferenciais parciais. Eles foram
vastamente programados em FORTRAN e em linguagem Assembly. Sistemas operacionais
típicos eram o FMS (Sistema Monitor FORTRAN) e IBSYS (Sistema Operacional da IBM para o
7094).
2.3 A Terceira Geração (1965 - 1980): Circuitos Integrados e Multiprogramação
Nos anos 60, muitos fabricantes de computadores tinham duas linhas de produto distintas
e totalmente incompatíveis. Por um lado havia os computadores científicos, em grande escala,
orientado por palavras, usados para cálculos numéricos em ciência e engenharia. Por outro lado,
havia os computadores comerciais, orientados por caractere, vastamente usados para
classificação em fita e impressão, por bancos e companhias de seguros.
A IBM, procurando resolver esse problema, introduziu o sistema /360. Uma série de
máquinas compatíveis por software, diferindo em tamanho, preço e performace. Todas as
máquinas tinham a mesma arquitetura e o mesmo conjunto de instruções. Sendo projetado para
manusear tanto computação comercial como computação científica. Esta foi a primeira linha de
computadores a usar (em pequena escala) circuitos integrados (CIs), fornecendo uma maior
vantagem em preço/performace sobre as máquinas da segunda geração, que eram construídas
de transistores individuais.
6
O resultado foi um sistema operacional enorme e extraordinariamente complexo, e de
magnitude maior do que o FMS. Ele consistia de milhares de linhas de linguagem Assembly
escritas por centenas de programadores e continha centenas e centenas de depurações que
necessitavam de contínuas versões a fim de corrigi-los.
O OS/360 e os sistemas operacionais similares da terceira geração, produzidos por outros
fabricantes, satisfizeram razoavelmente bem a seus clientes. Eles também popularizaram várias
técnicas ausentes nos sistemas operacionais da segunda geração. A mais importante dessas
técnicas foi a multiprogramação. No 7094, quando o job que estava sendo executado e tinha
uma pausa esperando que uma operação em fita ou em qualquer outro periférico I/O fosse
completada, a CPU simplesmente ficava ociosa até que a operação I/O fosse encerrada. Em
cálculos científicos pesados, as operações de I/O não são freqüentes, e esse tempo ocioso é
insignificante. Em processamento de dados comerciais, as operações de I/O consomem
freqüentemente entre 80% a 90% do tempo total, exigindo alguma providência sobre isso.
A solução foi particionar a memória em várias partes, com um job diferente em cada
partição. Enquanto um job estava esperando que uma operação I/O fosse concluída, um outro job
poderia usar a CPU. Se vários jobs pudessem ocupar a memória no mesmo instante, a CPU
estaria sempre ocupada quase que em 100% do tempo.
Um outro grande aspecto presente nos sistemas operacionais da terceira geração era a
habilidade de ler jobs de cartões para o disco assim que eles eram trazidos à sala do computador.
Assim, sempre que um job tinha a sua execução encerrada, o sistema operacional poderia
carregar um novo job do disco numa nova partição vazia e executá-lo. Essa técnica é chamada de
"spooling" (Simultaneous Perifheral Operation On Line) e também era usada para a saída. Com o
"spooling", os 1401s não precisavam ser tão grandes e a utilização da fita diminuiu bastante.
Com os sistemas da terceira geração, o tempo entre a submissão do job e a obtenção da
saída era freqüentemente de várias horas, onde a ausência de uma única vírgula causava uma
falha na compilação e o programador desperdiçava quase um dia.
A vontade de ter um tempo de resposta menor abriu espaço para "time-sharing", uma
variante da multiprogramação, em que cada usuário tem um terminal "on-line". Num sistema
"timesharing",
se 20 usuários estão conectados e 17 deles estão inativos, a CPU pode ser alocada
para os três jobs que querem serviço. Assim, o computador pode fornecer mais rápido, serviço
interativo a um número maior de usuários. Embora a primeira série de sistemas em time-sharing
(CTSS) foi desenvolvida no MIT num IBM 7094 especialmente modificado, ele não se tornou
verdadeiramente popular até que a necessidade de proteção de hardware ficasse mais difundida
durante a terceira geração.
Após o sucesso do sistema CTSS, o MIT, o Laboratório Bell e a General Eletric decidiram
desenvolver um "computador utilitário", uma máquina que suportasse milhares de usuários em
"time-sharing" simultaneamente. O seu modelo era baseado no sistema de distribuição de
eletricidade. Os projetistas desse sistema, conhecido como MULTICS (MULTiplexed Information
and Computing Service), tinham em mente uma grande máquina que fornecesse serviço de
computação para todos em Boston. O MULTICS introduziu muitas idéias inovadoras na literatura
da computação, mas a sua construção foi mais difícil do que se esperava. Mas a idéia de um
computador utilitário falhou. Mesmo assim, o MULTICS teve uma enorme influência nos sistemas
subseqüentes.
Outro importante desenvolvimento durante a terceira geração foi o crescimento fenomenal
de mini-computadores. Para certos tipos de trabalhos não-numéricos era quase tão rápido quanto
o 7094 e fez surgir uma nova indústria. Foi rapidamente seguido por uma série de outros.
Um dos cientistas do Laboratório Bell que trabalhou no MULTICS, Ken Thompson, logo
depois encontrou um pequeno PDP-7 que ninguém usava e começou a escrever uma versão
simplificada mono-usuário do MULTICS. Brian Kernighan apelidou esse sistema de UNICS
(UNiplexed Information and Computing Service), mas sua grafia foi mais tarde trocada para UNIX.
Posteriormente foi levado para um PDP-11/20, onde funcionou bem o bastante para convencer a
gerência do Laboratório Bell em investir no PDP-11/45 para continuar o trabalho.
Outro cientista do Laboratório Bell, Dennis Ritchie, juntou-se a Thompson para reescrever
o sistema numa linguagem de alto nível chamada C, projetada e implementada por Ritchie. O
Laboratório Bell licenciava o UNIX para Universidades quase de graça e dentro de poucos anos,
centenas delas estavam usando-o. O UNIX logo se estendeu para muitos outros computadores. O
7
UNIX tinha sido transportado para mais computadores do que qualquer outro sistema operacional
da história.
2.4 A Quarta Geração (1980-...): Computadores Pessoais
Com o desenvolvimento de circuitos integrados em larga escala (large scale integration —
LSI), que são chips contendo milhares de transistores em um centímetro quadrado de silício,
surgiu a era dos computadores pessoais. Se o minicomputador tomou possível para um
departamento, uma empresa ou uma universidade terem seu próprio computador, o chip
microprocessador tomou possível a um indivíduo qualquer ter seu próprio computador pessoal.
A grande variedade de capacidade computacional disponível, especialmente a capacidade
de computação altamente interativa com excelentes facilidades gráficas, fez crescer a indústria de
produção de software para computadores pessoais. Muitos desses softwares eram “amigáveis ao
usuário”, significando que eles foram projetados para usuários que não tinham conhecimento
algum sobre computadores.
Em 1974, a Intel lançou o 8080, e buscava um sistema operacional para testá-lo. Ela pediu
a um de seus consultores, Gary Kildall, para escrevê-lo. Ele utilizou um controlador que havia
construído para a então recém-lançada unidade de discos flexíveis de oito polegadas. Kildall
então escreveu para ele um sistema operacional baseado em disco denominado CP/M (control
program for microcomputers — programa de controle para microcomputadores). Como a Intel não
acreditava que microcomputadores baseados em disco tivessem muito futuro, Kildall requisitou os
direitos sobre o CP/M e a Intel os cedeu. Em 1977, a Digital Research reescreveu o CP/M para
torná-lo adequado à execução em muitos microcomputadores utilizando 8080 e outros
microprocessadores. Muitos programas de aplicação foram escritos para serem executados no
CP/M, permitindo que ele dominasse completamente o mundo da microcomputação por cerca de
cinco anos.
No início dos anos 80, a IBM projetou o IBM PC e buscou um software para ser executado
nele. O pessoal da IBM entrou em contato com Bill Gates para licenciar seu interpretador Basic.
Então Gates percebeu que um fabricante local de computadores possuía um sistema operacional
adequado, o DOS (disk operating system — sistema operacional de disco). Ele entrou em contato
com essa empresa e comprou-a. Gates então ofereceu à IBM um pacote DOS/Basic, e ela
aceitou. O sistema revisado teve seu nome mudado para MS-DOS (Microsoft disk operating
system — sistema operacional de disco da Microsoft) e rapidamente viria a dominar o mercado do
IBM PC. Mesmo com uma versão inicial bastante primitiva, as versões subsequentes do MS-DOS
incluíram aspectos mais avançados, muitos deles derivados do Unix. (A Microsoft conhecia bem o
Unix, pois, nos primeiros anos da empresa, vendeu uma versão para microcomputadores do Unix
denominada Xenix).
O CP/M, o MS-DOS e outros sistemas operacionais dos primeiros microcomputadores
eram todos baseados na digitação de comandos em um teclado feita pelo usuário. Isso finalmente
mudou graças a um trabalho de pesquisa de Doug Engeibart nos anos 60. Engeibart inventou
uma interface gráfica — voltada para o usuário — com janelas, ícones, menus e mouse,
denominada GUI (graphical user interface). Essas idéias foram adotadas por pesquisadores do
Xerox PARC e incorporadas às máquinas que eles projetaram. Steve Jobs, que co-inventou o
computador Apple, visitou o PARC, viu uma interface gráfica GUI e instantaneamente percebeu
seu potencial. Jobs então iniciou a construção de um Apple dispondo de uma interface gráfica
GUI. Esse projeto, denominado Lisa, foi. muito dispendioso e falhou comercialmente. A segunda
tentativa, o Apple Macintosh, foi um enorme sucesso, não somente por seu custo muito menor,
mas também porque era mais amigável, destinado a usuários nada sabiam sobre computadores.
A IBM e a Microsoft separaram suas estratégias no início de 1991. O OS/2 conquistou um
forte nicho em algumas grandes aplicações corporativas, auxiliado por sua estabilidade e
robustez, comparadas ao Windows 3.x. Mais tarde, a IBM faria uma última tentativa de fazer do
OS/2 o principal sistema operacional com seu OS/2 Warp 3.0, mais orientado ao consumidor
comum e lançado no final de 1994. Ele venderia milhões de cópias mas não diminuiria a grande
inclinação da indústria pelo Windows.
8
A Microsoft escreveu um sucessor para o MS-DOS fortemente influenciada pelo sucesso
do Macintosh. O sistema, denominado Windows 3.0, foi baseado na interface gráfica GUI, e era
executado originalmente em cima do MS-DOS e com isto, oferecendo compatibilidade com os
programas DOS. A interface com o usuário foi projetada trazendo um Gerenciador de Programas
baseado em ícones e um Gerenciador de Arquivos em estilo árvore. Imediatamente começaram a
aparecer os aplicativos, liderados pela divisão de aplicativos da própria Microsoft e seguidos por
todos os outros grandes desenvolvedores.
Para a maioria dos usuários de microcomputadores, a Microsoft ofereceu o Windows 3.1
avançado no final de 1991, que adicionava uma melhor integração de aplicativos, recursos
arrastar e soltar e uma maior estabilidade. Ele se tornou o padrão dominante para aplicativos para
PC e a Microsoft ocupou o papel de líder na definição das especificações multimídia.
A era do 286 já havia terminado no final de 1988, após a introdução do 386SX da Intel, um
processado que possuía os componentes internos de 32 bits do 386 e um barramento de dados
de 16 bits como o 286, o que o tornava barato. Este e o 386 original rebatizado de 386DX
dominaram as vendas de computadores durante anos. Em abril de 1989, a Intel apareceu com
seus processadores 486. Com 1,2 milhões de transistores, o 486 era, efetivamente, uma versão
mais rápida e mais refinada do 386 somada a um co-processador matemático que executava
todos os aplicativos escritos para o 386 sem quaisquer problemas.
A Intel produziu seu Processador Pentium de 60 MHz em março de 1993, mas não eram
apenas os processadores que continuavam a avançar. Os discos rígidos ficavam cada vez
maiores e mais velozes. E a tecnologia de exibição gráfica progrediu das placas de vídeo de
“buffer de quadro” para as aceleradoras gráfica, que trabalhavam diretamente com o Windows a
fim de aumentar os tempos de resposta de tela e melhorar os gráficos em geral.
Em 1995 lançou-se uma versão do Windows independente do MS-DOS, o Windows 95. O
Windows incorporou muitos aspectos de um sistema operacional, usando o MS-DOS apenas para
ser carregado e executar programas antigos. Ele tinha a multitarefa preemptiva, era compatível
com Plug-and-Play, suportava novos padrões de e-mail e comunicações e trazia uma nova
interface com o usuário. Em 1998, lançou-se uma versão levemente modificada desse sistema,
chamada Windows 98.
Um outro sistema operacional da Microsoft é o Windows NT (new technology), que é
compatível com o Windows 95 em um certo nível, mas reescrito internamente por completo.
Somente com a versão Windows NT 4.0 foi que ele finalmente deslanchou, especialmente em
redes corporativas. A versão 5 do Windows NT foi renomeada para Windows 2000 no início de
1999. Seu objetivo era suceder tanto o Windows 98 quanto o Windows NT 4.0, mas também não
obteve êxito, e então a Microsoft lançou mais uma versão do Windows 98 denominada Windows
Me (Millenium edition).
O outro grande competidor no mundo dos computadores pessoais é o Unix (e seus vários
derivados). O Unix é o mais forte em estações de trabalho e em outros computadores mais
avançados, como os servidores de rede. Em computadores baseados em Pentium, o Linux está
se tornando uma alternativa popular para estudantes e apresenta um crescente número de
usuários corporativos.
O Kernel do Linux foi, originalmente, escrito por Linus Torvalds do Departamento de
Ciência da Computação da Universidade de Helsinki, Finlândia, com a ajuda de vários
programadores voluntários através da Internet. começou o desenvolvimento do kernel como um
projeto particular, inspirado pelo seu interesse no Minix, um pequeno sistema UNIX desenvolvido
por Andrew S. Tanenbaum. A letra “X” foi herdada do UniX e a associação do nome “Linus” com o
“Unix”, deu nome ao LINUX. No dia 5 de outubro de 1991 Linus Torvalds anunciou a primeira
versão "oficial" do 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 operativo/operacional que é hoje.
Atualmente quase todos os sistemas Unix suportam um sistema de janelas denominado X
(X Windows) escrito no MIT. Esse sistema trata o gerenciamento básico de janelas de modo que
permita que usuários criem, removam, movam e redimensionem as janelas usando um mouse.
9
Fase 1ª
(1945-1955)
2ª
(1955-1965)
3ª
(1965-1980)
4ª
(1980-1990)
5ª
(1991- )
Computadores
ENIAC
EDVAC
UNIVAK
NCR
IMB 7094
CDC-6600
IBM 360, 370
PDP-11
Cray 1
Cyber-205
Cray XMP
IBM 308
VAX-11
IBM-PC
IBM 3090
Alpha AXP
Pentium
Sun SPARC
Hardware Válvulas
Tambor
Magnético
Tubos de raios
catódicos
Transistor
Memória
Magnética
Circuito Integrado
Disco Magnético
Minicomputador
Microprocessador
LSI ou VLSI
Disco óptico
Microcomputador
Ultra-LSI
Arquiteturas Paralelas
Circuto Integrado 3-D
Software Linguagem de
Máquina
Linguagem
assembly
Linguagem de
Alto Nível
Processamento
Batch
Linguagem
Estruturadas
Multiprogramação
Time-Sharing
Computação
Gráfica
Multiprocessamento
Sistemas
Especialistas
Linguagens
orientadas a objetos
Processamento
Distribuído
Linguagens
concorrentes
Programação funcional
Linguagens naturais
Telecomunicações Telefone
Teletipo
Transmissão
Digital
Comunicação via
satélite
Microondas
Redes
distribuídas(WAN)
Fibra óptica
Redes Locais (LAN)
Internet
Redes Locais
estendidas(ELAN)
Redes sem fio
Modelo cliente-servidor
Desempenho 10 ips 200.000 ips 5 Mips 30 Mips 1 Gflops
1 Tflops
Características de cada fase
10
3. Tipos de Sistemas Operacionais
Os sistemas operacionais podem ser classificados segundo diversos parâmetros e
perspectivas, como tamanho, velocidade, suporte a recursos específicos, acesso à rede, etc.
Um sistema operacional deve levar em conta mais do que simplesmente o número de
aplicativos ou de usuários. Em alguns casos, é suficiente responder aos aplicativos em seqüência.
Por outro lado, alguns sistemas operacionais tentam garantir uma resposta rápida às
necessidades do usuário. Ainda em outros casos, um sistema deve responder dentro de um certo
intervalo de tempo para evitar desastres. Tudo depende das necessidades do usuário, de suas
expectativas e dos aplicativos executados. A seguir são apresentados alguns tipos de sistemas
operacionais usuais (muitos sistemas operacionais se encaixam bem em mais de uma das
categorias apresentadas.
3.1 Sistemas Monotarefa
Projetados para serem usados por um único usuário, permitem que apenas um programa
(tarefa) seja executado de cada vez. Nos sistemas monotarefa, somente um programa pode estar
residente em memória, e a CPU permanece dedicada, exclusivamente, à execução desse
programa, como mostra a figura abaixo. Podemos observar que, nesse tipo de sistema, ocorre um
disperdício na utilização da CPU, pois enquanto o programa está realizando, por exemplo, uma
leitura em disco, o processador permanece sem realizar nenhuma tarefa. O tempo de espera é
consideravelmente grande, já que as operações com dispositivos de E/S são muito lentas se
comparadas com a velocidade da CPU
Ex: MS-DOS. CPM.
P1 P2
tempo
processos
- ociosidade
...
- executando
3.2 Sistemas Multitarefa
Sistemas Multitarefa podem ser divididos em duas categorias, Monousuário e Multiusuário:
3.2.1 Monousuário
Comportam um usuário que pode executar várias atividades ao mesmo tempo. São muito
mais complexos e eficientes que os sistemas monotarefa.
Nestes Sistemas, enquanto uma tarefa aguarda a ocorrência de um evento da CPU, esta
pode atender outra tarefa qualquer que esteja em condições de ser executada. O sistema
operacional se encarrega de gerenciar o acesso concorrente das diversas tarefas aos diversos
recursos de forma ordenada e protegida. Situação: um documento sendo impresso. O sistema
permite fazer outras coisas, como editar um arquivo. Para todos os fins, o editor e a impressão
estão funcionando ao mesmo tempo. Realidade: o sistema operacional reconhece duas entidades:
o editor e a tarefa de impressão, e permite que eles se alternem no uso da CPU e de outros
11
recursos. As tarefas se alternam tão rapidamente que não se notam as interrupções. A
capacidade multitarefa permite estabelecer um escalonamento das atividades.
As funções do sistema operacional tornam-se mais complexas. Múltiplas tarefas significam
que mais software deve residir na memória. O sistema operacional tem de garantir que os
programas não interfiram uns com os outros e deve executar o planejamento da execução dessas
tarefas (escalonamento).
Ex: Windows 3.x, Windows 9x, Millenium, XP, Seven.
P1
P2
tempo
processos
- ociosidade
...
- executando
3.2.2 Multiusuário
O sistema operacional tem de manter controle de vários usuários e impedir que eles
interfiram uns com os outros. Situação: um computador de uma grande empresa. Muitos de seus
aplicativos são executados em um único computador de grande porte. Com um programa
tentando acessar a memória ocupada por outro. Um sistema operacional deve impedir esse tipo
de atividade;
Por outro lado, às vezes os programas têm de compartilhar dados. A elaboração do
escalonamento se torna mais importante em um sistema multiusuário, pois ele deve satisfazer às
necessidades de muitos. O sistema operacional deve decidir quem obterá o que, e quando. Em
geral, o sistema operacional atribui uma prioridade para cada programa.
Ex: Windows NT (2000), UNIX.
3.3 Sistemas Desktop
Um sistema operacional “de mesa” é voltado ao atendimento do usuário doméstico e
corporativo para a realização de atividades corriqueiras, como edição de textos e gráficos,
navegação na internet e reprodução de mídias simples. Suas principais características são a
interface gráfica, o suporte a interatividade e a operação em rede.
Exemplos: Windows XP, Mac OS e Linux.
3.4 Sistemas Embutidos
Um sistema operacional é dito embutido (embedded) quando é construído para operar
sobre um hardware com poucos recursos de processamento, armazenamento de energia.
Aplicações típicas desse tipo de sistema aparecem em telefones celulares, controladores
automotivos, equipamentos eletrônicos de uso domestico (aparelhos de DVD, TVs, microondas,
centrais de alarme, etc.).
3.5 Sistemas em Batch (Lote)
` Os sistemas operacionais mais antigos trabalhavam “por lote”, ou seja, todos os programas
a executar eram colocados em uma fila, com seus dados e demais informações para a execução.
12
O processador recebia um programa após o outro, processando-os em sequência, o que permitia
um alto grau de utilização do sistema. Ainda hoje o termo “em lote” é usado para designar um
conjunto de comandos que deve ser executado em sequência sem interferência do usuário.
Exemplos destes sistemas incluem o OS/360 e VMS, entre outros.
3
.6 Sistemas de Tempo Real
Ao contrario da concepção usual, um sistema operacional de tempo real não precisa ser
necessariamente ultra rápido; sua característica essencial é ter um comportamento temporal
previsível, ou seja, seu tempo de resposta deve ser no melhor e pior caso de operação. A
estrutura interna de um sistema operacional de tempo real deve ser construída de forma a
minimizar esperas e latências imprevisíveis, como tempos de acesso a disco e sincronizações
excessivas. Existem duas classificações de sistemas de tempo real: soft real-time systems, nos
quais a perda de prazos implica na degradação dos serviços prestados. Um exemplo seria o
suporte a gravação de CDs ou a reprodução de musicas. Caso o sistema se atrase, pode ocorrer
a perda da mídia em gravação ou falhas na musica que esta sendo tocada. Por outro lado, nos
hard real-time systems a perda de prazos pelo sistema pode perturbar o objeto controlado, com
graves conseqüências humanas econômicas ou ambientais.
Exemplos desse tipo de sistema seriam o controle de funcionamento de uma turbina de
avião a jato, de uma caldeira industrial ou de uma usina nuclear.
3.7 Sistemas de Rede
Caracterizam-se pela existência de vários computadores independentes interligados em
rede e compartilhando alguns recursos tais como disco, impressora, scanner e outros. Um sistema
operacional de rede se encarrega de propiciar o protocolo para comunicação e transferência de
dados entre os usuários e servidores de rede. Cada computador da rede é independente e capaz
de executar sua própria aplicação.
3.8 Sistemas Servidores
Um sistema operacional servidor deve permitir a gestão eficiente de grandes quantidades
de recursos (disco, memória, processadores), impondo prioridades e limites sobre o uso dos
recursos pelos usuários e seus aplicativos. Normalmente um sistema operacional servidor
também tem suporte a rede e multiusuários.
3.9 Sistemas Distribuídos
São conceitualmente sistemas em rede que possibilitam uma integração e uma
cooperação transparente entre os diversos nós que compõem uma rede. Em um sistema
operacional distribuído, os recursos de cada máquina estão disponíveis globalmente, de forma
transparente aos usuários.
Computadores interconectados visando possibilitar a execução de um serviço. Ao lançar
uma aplicação, o usuário interage com sua janela, mas não sabe onde ela esta executando ou
armazenando seus arquivos: o sistema é quem decide.
Os sistemas operacionais distribuídos já existem há tempos (Amoeba [TKvRB91] e Clouds
[DRJLAR91], por exemplo), mas ainda não são uma realidade de mercado.
3
.10 Sistemas Paralelos ou Multiprocessados
Caracterizam-se por permitir a execução simultânea de duas ou mais instruções, o que
requer a existência de mais de um processador. O multiprocessamento pode ser obtido pela
configuração de múltiplos processadores que compartilham de uma mesma memória primária.
Os sistemas multiprocessados permitem que vários programas sejam executados em
paralelo, ou que um programa tenha duas ou mais de suas instruções executadas em paralelo
13
4. Arquitetura do Sistema Operacional
Podemos definir a arquitetura de um Sistema Operacional como a estrutura que é
composta de diversos componentes com objetivos e funcionalidades complementares.
Alguns dos componentes mais relevantes de um sistema operacional típico são:
4.1 Núcleo
É o coração do sistema operacional, responsável pela gerencia dos recursos do hardware
usados pelas aplicações. Ele também implementa as principais abstrações utilizadas pelos
programas aplicativos.
Também chamado de kernel, que é entendido como o núcleo deste ou, numa tradução
literal, cerne. Ele representa a camada mais baixa de interface com o Hardware, sendo o
responsável por gerenciar os recursos do sistema computacional como um todo. É no Kernel que
estão definidas as funções para operação com periféricos (mouse, discos, impressoras, interface
serial/interface paralela), gerenciamento de memória, entre outros. Resumidamente, o Kernel é
um conjunto de programas que fornece para os programas de usuário (aplicativos) uma interface
para utilizar os recursos do sistema.
O Kernel é a parte mais importante do Sistema Operacional, pois, sem ele, a cada
programa novo que se criasse seria necessário que o programador se preocupasse em escrever
as funções de entrada/saída, de impressão, entre outras, em linguagem de baixo nível, causando
uma duplicação de trabalho e uma perda enorme de tempo. Como o Kernel já fornece a interface
para que os programas possam acessar os recursos do sistema de um nível mais alto e de forma
transparente, fica resolvido a duplicação do trabalho.
Quanto á sua arquitetura, o kernel pode ser monolítico (em um único bloco), com todas
suas funcionalidades carregadas na memória, ou modular, com módulos específicos para cada
tarefa carregados opcionalmente, dinamicamente.
4.2 Drivers
Módulos de código especifico para acessar os dispositivos físicos. Existe um driver para
cada tipo de dispositivo, como discos rígidos IDE ou SATA, porta USB, placas de vídeo, placas de
som, adaptador de rede, etc. Quando há periféricos ou elementos de um sistema computacional
que o kernel não cobre, então se faz necessário escrever a interface para eles. Eles "ensinam" ao
sistema como lidar com estes recursos "extras". Este é o papel do driver, um pequeno programa
carregado em memória que instrui ao sistema como trabalhar com um determinado periférico.
Muitas vezes o driver é construído pelo próprio fabricante do hardware e fornecido em forma
binária para ser acoplado ao restante do sistema operacional.
4.3 Código de Inicialização
A inicialização do hardware requer uma série de tarefas complexas, como reconhecer os
dispositivos instalados, testá-los e configurá-los adequadamente para o seu uso posterior. Outra
tarefa importante é carregar o núcleo do sistema operacional em memória e iniciar sua execução.
4.4 Programas Utilitários
São programas que facilitam o uso do sistema computacional, fornecendo funcionalidades
complementares ao núcleo, como formatação de discos e mídias, configuração de dispositivos,
manipulação de arquivos (mover, copiar, apagar), Interpretador de comandos, interface gráfica,
gerencia de janelas, etc.
As diversas partes do sistema operacional se relacionam entre si conforme apresentado na
figura abaixo:
14
15
5. O Sistema Operacional Como um Gerenciador de Recursos
O sistema operacional tem diversas funções no sistema computacional onde está
instalado. Entretanto poderíamos afirmar que basicamente o S.O. realiza duas funções não
relacionadas anteriormente: estender a máquina e gerenciar recursos. Segundo isso o trabalho do
sistema operacional é fornecer uma alocação ordenada e controlada de processadores, memórias
e dispositivos de E/S entre vários programas que competem por eles.
Situação: três programas em execução tentando imprimir suas saídas simultaneamente na
mesma impressora. Quando um computador (ou uma rede) tem múltiplos usuários, a necessidade
de gerenciar e proteger os recursos é maior. Com usuários muitas vezes precisando compartilhar
não somente hardware, mas também informação (arquivos, bancos de dados, etc.). Essa visão do
sistema operacional mostra que sua tarefa principal é manter o controle sobre quem está usando
qual recurso, garantindo suas requisições de recursos, controlando as contas e mediando conflitos
de requisições entre diferentes programas e usuários. O gerenciamento de recursos realiza o
compartilhamento (ou multiplexação) desses recursos de duas maneiras:
No tempo: Diferentes programas ou usuários aguardam a sua vez de usá-lo. Determinar
como o recurso é compartilhado no tempo (quem vai depois de quem e por quanto tempo) é tarefa
do sistema operacional. Exemplo: somente uma CPU e múltiplos programas precisando ser
executados nela. Outro exemplo: múltiplas saídas são enfileiradas para imprimir em uma única
impressora.
No espaço: Em lugar de ficar esperando sua vez, cada um ocupa uma parte do recurso.
Exemplo: memória principal é dividida entre vários programas em execução, que residem ao
mesmo tempo nela. Outro recurso compartilhado é o disco (rígido). Um único disco pode conter
arquivos de muitos usuários ao mesmo tempo. Alocar espaço em disco e manter o controle sobre
quem está usando quais parcelas do disco é uma típica tarefa de gerenciamento de recursos.
Um sistema operacional multiprogramado suporta a execução de múltiplos programas de
usuários, em paralelo. Em sua organização possui: Tratador de Interrupções, Drivers dos
dispositivos, um gerenciador de memória, um gerenciador de processos, que possui um
escalonador, responsável pela seleção e disparo de programas, por um gerenciador de arquivos,
por um seqüenciador de programas e pelos programas de usuários em execução. A figura a
seguir mostra esquematicamente os componentes de um sistema operacional multiprogramado.
5.1 Gerência de Processos
O conceito mais central em qualquer S.O. é o conceito de processo. Um processo é
basicamente um programa em execução acompanhado de seu espaço de endereço, dos valores
16
atuais do contador de programa, dos registradores e das variáveis. Todos os softwares que
podem executar em um computador são organizados em vários processos seqüenciais.
Num siisttema mullttiiprrogrramado o ttempo do prrocessadorr é diisttrriibuíído enttrre os
prrogrramas
em execução.. Várriios prrocessos comparrttiillham uma mesma CPU.. Perriiodiicamentte,, o S..O..
deciide
parrarr de executtarr um prrocesso e começa a executtarr outtrro porrque o prriimeiirro jjá tteve a
porrção que
llhe cabe a CPU.. Cada prrogrrama executta porr cerrtto ttempo.. a CPU salltta de prrogrrama parra
prrogrrama,, executtando cada um delles porr dezenas ou centtenas de miilliissegundos. Enquanto
a
cada instante a CPU executa somente um programa, no decorrer de um segundo ela pode
trabalhar sobre vários programas, criando a ilusão de paralelismo.
5.1.1 Estados de um Processo
Um processo tem três estados:
1. Em execução: usando a CPU naquele instante.
2. Pronto: executável, temporariamente parado para dar lugar a outro processo.
3. Bloqueado: incapaz de executar enquanto um evento externo não ocorrer.
5.1.2 Criação e Término de Processos
Em um sistema operacional de propósito geral é necessário algum modo de criar e
terminar processos durante a operação, quando for preciso. Há quatro eventos principais que
fazem com que processos sejam criados:
1. Início do sistema: quando um sistema operacional é carregado criam-se vários
processos. Alguns são em primeiro plano, que interagem com o usuário e realizam tarefas para
eles. Outros são em segundo plano, e estão associados a um usuário, mas que apresentam
alguma função específica.
2. Execução de uma chamada ao sistema de criação de processo por um processo em
execução: após a carga do sistema operacional, um processo em execução pode realizar uma
chamada ao sistema para criar um ou mais novos processos para ajudá-lo em seu trabalho.
3. Uma requisição do usuário para criar um novo processo: em sistemas interativos os
usuários podem iniciar um programa através de um comando ou clicando em um ícone. Cada uma
dessas ações inicia um novo processo e executa nele o programa selecionado.
4. Início de um job em lote: aplica-se a sistemas em lote em computadores de grande
porte, onde usuários podem submeter jobs em lote para o sistema. Quando julgar que tem
recursos para executar o job, o sistema operacional criará um novo processo e executará nele o
próximo job da fila de entrada.
Depois de criado, um processo começa a executar e faz seu trabalho. Chega uma hora em
que o processo terminará, em razão das seguintes condições:
1. Saída Normal (voluntária): quando acaba de compilar o programa atribuído a ele, o
compilador executa uma chamada ao sistema para comunicar ao sistema operacional que ele
terminou. Programas baseados em tela suportam o término voluntário através de um ícone ou de
um item de menu.
pronto execução
bloqueado
entrada
ativação
remoção
saída
desbloqueio bloqueio
17
2. Saída por erro (voluntária): ocorre quando o processo descobre um erro fatal.
Programas interativos apresentam uma mensagem quando isto ocorre.
3. Erro fatal (involuntário): é um erro causado pelo processo por um erro de programa.
Podendo ser a execução de uma instrução ilegal, referência à memória inexistente, divisão por
zero, etc.
4. Cancelamento por outro processo (involuntário): acontece quando um processo executa
uma chamada ao sistema dizendo ao sistema operacional para cancelar algum outro processo.
Quando um processo termina voluntariamente ou não todos os processos por ele criados são
imediatamente cancelados.
5.1.3 Escalonamento de Processos
Chamamos de escalonamento (scheduling) de processos, o ato de realizar o chaveamento
de processos prontos para executar de acordo com regras bem estabelecidas, de forma a que
todos tenham sua chance de utilizar a CPU. A parte do S.O. responsável por este chaveamento
de processos é o escalonador que usa um algoritmo de escalonamento para decidir, a cada
instante, qual o próximo processo a ser executado. Nos sistemas de lote dos anos 60, o algoritmo
de escalonamento era simples: executar a próxima tarefa (job) da fila. Hoje, com os sistemas de
tempo compartilhado, multiusuário, o algoritmo de escalonamento é bem mais complexo.
Um bom algoritmo de escalonamento tem que incluir os seguintes critérios:
1. Justiça: cada processo tem que ter uma parte justa do tempo de CPU.
2. Eficiência: garantir uma ocupação de 100% do tempo de CPU.
3. Tempo de Resposta Mínimo: minimizar o tempo de resposta para os usuários
interativos.
4. Minimizar o intervalo de tempo entre a submissão de um trabalho e a obtenção dos
resultados de volta.
5. Maximizar o número de trabalhos processados por hora.
As categorias (tipos) dos escalonadores são:
1. Preemptivo: O processo pode ser interrompido, sendo retirado da CPU para executar
posteriormente.
2. Não Preemptivo: O processo não é retirado da CPU. Ele mantém-se em execução até
liberar a CPU ou em caso de erro
5.1.3.1 Algoritmos de Escalonamento
Existem vários algoritmos utilizados para atingir os objetivos de escalonamento, são eles:
1. FIFO (First In First Out – Primeiro a entrar é o primeiro a sair): É o algoritmo mais
simples, pois retira os processos da fila de aptos na ordem de chegada. Ele escolhe quem está a
mais tempo na fila. E é um algoritmo não-preemptivo.
2. SJF (Shortest Job First - Menor Job Primeiro): Seleciona o processo cujo “próximo ciclo”
(quantidade de tempo que vai executar) é o menor. Ele é um algoritmo não-preemptivo. Na
implementação a fila (lista) pode ser ordenada em ordem crescente de utilização da CPU para
facilitar a busca.
3. Prioridade: Cada processo possui uma prioridade, sendo que o de maior prioridade é
escolhido para executar. Pode ser preemptivo ou não-preemptivo. Na implementação a fila (lista)
pode ser ordenada em ordem crescente de prioridade para facilitar a busca. Daí no momento da
escolha o escalonamento funciona como uma FIFO.
4. Round-Robin (Fatia de Tempo): Cada processo recebe uma fatia de tempo (quantum)
para utilizar o processador. E esta fatia de tempo pode ser implementada da seguinte forma:
Quando o quantum se esgota o processo entra no fim da fila, ou seja, quando o processo liberar a
CPU. Além disso, ao ser criado o processo vai para o fim da fila. No momento da escolha o
escalonamento funciona como uma FIFO. Ele é um algoritmo preemptivo que define a idéia de
justiça. Não possui postergação indefinida e as fatias de tempo são delimitadas por interrupções.
18
5.1.4 Hierarquias de Processos
Um processo pode criar um ou mais processos, chamados processos filhos, e esses
processos, por sua vez, podem criar outros processos filhos, rapidamente pode-se chegar a uma
estrutura de árvores como a seguinte:
5.1.5 Comunicação Entre Processos
Processos relacionados que estiverem cooperando para executar alguma tarefa precisam
freqüentemente se comunicar um com o outro e sincronizar suas atividades. Essa comunicação é
chamada de comunicação interprocessos. A partir deste conceito, temos dois tipos de
processos:
1. Processos independentes: não apresentam relacionamentos com outros processos.
2. Processos Concorrentes: quando dois ou mais processos precisam comunicar-se entre
si. Implicando em um compartilhamento de recursos, que deve ser feito visando manter um
funcionamento coerente e correto do sistema.
5
.1.5.1 Condições de Disputa
Em alguns S.Os, processos que trabalham juntos normalmente compartilham alguma
memória comum que cada um pode ler e escrever. A memória compartilhada pode estar na
memória principal ou pode ser um arquivo compartilhado. Um exemplo prático de comunicação
entre processos é o spooler de impressora.
Quando um processo quer imprimir um arquivo, ele entra o nome do arquivo num diretório
spooler especial. Um outro processo (daemon de impressora), verifica periodicamente, se existem
arquivos para serem impressos e, se houverem, ele os imprime e remove seus nomes do diretório
spooler.
5
.1.5.2 Seções (ou regiões) Críticas
Trata-se de uma ou mais variáveis comuns utilizadas conjuntamente por diversos
processos. Um sistema apresenta várias regiões críticas distintas.
A forma de se prevenir contra situações de disputa envolvendo memória compartilhada,
arquivos compartilhados, ou qualquer outro recurso compartilhado, é encontrar uma forma de
proibir mais de um processo de ler e escrever o dado compartilhado ao mesmo tempo. O
mecanismo utilizado para impedir tal fato é chamado de Exclusão Mútua, que se trata de uma
forma de certificar que se um processo está usando uma variável ou arquivo compartilhado, o
outro processo vai ser impedido de fazer o mesmo, ou seja, enquanto um processo está ocupado
em sua seção crítica, nenhum outro processo vai utilizar a região crítica e causar problemas.
Entretanto, para evitar que um processo fique utilizando um recurso ininterruptamente, o
S.O. precisa efetuar mecanismos de sincronização. Para controlar a comunicação entre processos
sem comprometer a segurança dos dados de cada um, quando envolve variáveis comuns entre
eles e fazer com que nenhum processo fique esperando infinitamente para entrar na região crítica.
A
CB
EDF
19
5.1.5.3 Deadlock
Situação na qual um, ou mais processos, fica impedido de prosseguir a sua execução
devido ao fato de cada um estar aguardando acesso a recursos já alocados por outros processos.
Em outras palavras um ou mais processos está aguardando a liberação de um recurso por outro
processo que, por sua vez, aguarda a liberação de outro recurso alocado ou dependente do
primeiro processo. Para ocorrer um deadlock é preciso ocorrer estes quatro eventos:
1. Exclusão mútua.
2. Segura/Espera: processo que detém um recurso pode solicitar outros recursos;
3. Recurso não-preemptível: um recurso concedido não pode ser retirado de um processo
por outro.
4. Espera circular: existência de um ciclo de dois ou mais processos cada um esperando
por um recurso em uso pelo próximo processo no ciclo.
Recurso 1 Recurso 2
Processo A
Processo B
solicitação
solicitação alocação
alocação
20
6. Gerência de Memórias
Todo computador tem uma memória principal que ele usa para guardar os programas em
execução. Sistemas operacionais permitem que múltiplos programas residam na memória
principal ao mesmo tempo. Para mantê-los livres da interferência dos outros programas (e do
sistema operacional), é necessário algum tipo de mecanismo de proteção.
A maioria dos computadores utiliza uma hierarquia de memórias: uma pequena memória
cache, volátil, muito rápida e de custo alto; uma grande memória principal (RAM), volátil, de
velocidade e custos médios; e uma memória secundária, constituída de armazenamento não
volátil em disco, com dezenas de centenas de gigabytes, velocidade e custos baixos. Cabe ao
sistema operacional coordenar a utilização dessas memórias. Os programas são armazenados no
disco. Executar um programa é transferi-lo da memória secundária (disco) para a memória
primária (RAM). A CPU e os periféricos de E/S também interagem com a memória principal. O
núcleo do sistema operacional também ocupa parte da memória principal.
A parte do sistema operacional que gerencia a hierarquia de memórias é denominada
gerenciador de memória. Sua função é manter o controle de quais partes da memória estão em
uso e quais não estão, alocando memória aos processos quando eles precisam e liberando a
memória quando esses processos terminam, além de gerenciar a troca de processos entre a
memória e o disco quando a memória principal não é suficiente para conter todos os processos.
Historicamente, a memória principal sempre foi vista como um recurso escasso e caro.
Uma das maiores preocupações dos projetistas foi desenvolver sistemas operacionais que não
ocupassem muito espaço de memória e, ao mesmo tempo, aperfeiçoassem a utilização dos
recursos computacionais. Mesmo atualmente, com a redução de custo e conseqüente aumento da
capacidade da memória principal, seu gerenciamento é um dos fatores mais importantes no
projeto de sistemas operacionais.
Enquanto nos sistemas monoprogramáveis a gerência da memória não é muito complexa,
nos sistemas multiprogramáveis essa gerência se torna crítica, devido à necessidade de se
maximizar o número de usuários e aplicações utilizando eficientemente o espaço da memória
principal. Veremos agora quais os mecanismos utilizados para gerenciar a memória principal:
6.1 Alocação Contígua Simples
A alocação contígua simples foi implementada nos primeiros sistemas operacionais, porém
ainda está presente em alguns sistemas monoprogramáveis. Nesse tipo de organização, a
memória principal é subdividida em duas áreas: uma para o sistema operacional e outra para o
programa do usuário.
Alocação contígua simples
Dessa forma, o programador deve desenvolver suas aplicações, preocupado, apenas, em
não ultrapassar o espaço de memória disponível, ou seja, a diferença entre o tamanho total da
memória principal e a área ocupada pelo sistema operacional.
Nesse esquema, o usuário tem controle sobre toda a memória principal, podendo ter
acesso a qualquer posição de memória, inclusive a área do sistema operacional. Para proteger o
sistema desse tipo de acesso, que pode ser intencional ou não, alguns sistemas implementam
proteção através de um registrador que delimita as áreas do sistema operacional e do usuário.
21
Proteção na alocação contígua simples
Dessa forma, sempre que um programa faz referência a um endereço na memória, o
sistema verifica se o endereço está dentro dos limites permitidos. Caso não esteja, o programa é
cancelado e uma mensagem de erro é gerada, indicando que houve uma violação no acesso à
memória principal.
Apesar de fácil implementação e do código reduzido, a alocação contígua simples não
permite a utilização eficiente dos recursos computacionais, pois apenas um usuário pode dispor
desses recursos. Em relação à memória principal, caso o programa do usuário não a preencha
totalmente, existirá um espaço de memória livre sem utilização.
Subutilização da memória principal
6.2 Técnica de Overlay
Na alocação contígua simples, todos os programas estão limitados ao tamanho da área de
memória principal disponível para o usuário. Uma solução encontrada para o problema é dividir o
programa em módulos, de forma que seja possível a execução independente de cada módulo,
utilizando uma mesma área de memória. Essa técnica é chamada de overlay.
Considere um programa que tenha três módulos: um principal, um de cadastramento e
outro de impressão, sendo os módulos de cadastramento e de impressão independentes. A
independência do código significa que quando um módulo estiver na memória para execução, o
outro não precisa necessariamente estar presente. O módulo principal é comum aos dois
módulos; logo, deve permanecer na memória durante todo o tempo da execução do programa.
Como podemos verificar na figura abaixo, a memória é insuficiente para armazenar todo o
programa, que totaliza 9kb. A técnica de overlay utiliza uma área de memória comum, onde os
módulos de cadastramento e de impressão poderão compartilhar a mesma área de memória (área
de overlay). Sempre que um dos dois módulos for referenciado pelo módulo principal, o módulo
será carregado da memória secundária para a área de overlay. No caso de uma referência a um
módulo que já esteja na área de overlay, a carga não é realizada; caso contrário, o novo módulo
irá sobrepor-se ao que já estiver na memória principal.
22
Técnica de overlay
A definição das áreas de overlay é função do programador, através de comandos
específicos da linguagem de programação utilizada. O tamanho de uma área de overlay é
estabelecido a partir do tamanho do maior módulo.
A técnica de overlay tem a vantagem de permitir ao programador expandir os limites da
memória principal. A utilização dessa técnica exige muito cuidado, pois pode trazer implicações
tanto na sua manutenção quanto no desempenho das aplicações, devido à possibilidade de
transferência excessiva dos módulos entre a memória principal e a secundária.
6.3 Alocação Particionada
Os sistemas operacionais evoluíram no sentido de proporcionar melhor aproveitamento
dos recursos disponíveis. Nos sistemas monoprogramáveis, o processador permanece grande
parte do tempo ocioso e a memória principal é subutilizada. Os sistemas multiprogramáveis já são
muito mais eficientes no uso do processador, necessitando, assim, que diversos programas
estejam na memória principal ao mesmo tempo e que novas formas de gerência da memória
sejam implementadas.
6.3.1 Alocação Particionada Estática
Nos primeiros sistemas multiprogramáveis, a memória era dividida em pedaços de
tamanho fixo, chamados partições. O tamanho das partições, estabelecido na fase de inicialização
do sistema, era definido em função do tamanho dos programas que executariam no ambiente.
Sempre que fosse necessária a alteração do tamanho de uma partição, o sistema deveria ser
desativado e reinicializado com uma nova configuração. Esse tipo de gerência de memória é
conhecido como alocação particionada estática ou fixa.
23
Inicialmente, os programas só podiam ser carregados e executados em apenas uma
partição específica, mesmo se outras estivessem disponíveis. Essa limitação se devia aos
compiladores e montadores, que geravam apenas códigos absolutos. No código absoluto, todas
as referências a endereços no programa são posições físicas na memória principal, ou seja, o
programa só poderia ser carregado a partir do endereço de memória especificado no seu próprio
código. Se, por exemplo, os programas A e B estivessem sendo executados, e a terceira partição
estivesse livre,os programas C e E não poderiam ser processados. A esse e tipo de gerência
de memória chamou-se alocação particionada estática absoluta.
Alocação particionada estática absoluta
Com a evolução dos compiladores, montadores, linkers e loaders, o código gerado deixou
de ser absoluto e passa a ser relocável. No código relocável, todas as referências a endereços no
programa são relativas ao início do código e não a endereços físicos de memória. Desta forma, os
programas puderam ser executados a partir de qualquer partição. Quando o programa é
carregado, o loader calcula todos os endereços a partir da posição inicial onde o programa foi
alocado. Caso os programas A e B terminassem, o programa E poderia ser executado em
qualquer uma das duas partições. Esse tipo de gerência de memória é denominado alocação
particionada estática relocável.
Alocação particionada estática relocável
Para manter o controle sobre quais partições estão alocadas, a gerência de memória
mantém uma tabela com o endereço inicial de cada partição, seu tamanho, e se está em uso.
Sempre que um programa é carregado para a memória, o sistema percorre a tabela, na tentativa
de localizar uma partição livre, onde o programa possa ser carregado.
24
Tabela de alocação de partições
Nesse esquema de alocação de memória, a proteção baseia-se em dois registradores, que
indicam os limites inferior e superior da partição onde o programa está sendo executado. Caso o
programa tente acessar uma posição de memória fora dos limites definidos pelos registradores,
ele é interrompido e uma mensagem de violação de acesso é gerada pelo sistema operacional.
Proteção na alocação particionada
Tanto nos sistemas de alocação absoluta quanto nos de alocação relocável, os programas,
normalmente, não preenchem totalmente as partições onde são carregados. Por exemplo, os
programas C, A e E não ocupam integralmente o espaço das partições onde estão alocados,
deixando 1kb, 3kb e 5kb de áreas livres, respectivamente. Este tipo de problema, decorrente da
alocação fixa das partições, é conhecido como fragmentação interna.
25
Fragmentação interna
6.3.2 Alocação Particionada Dinâmica
A alocação particionada estática, analisada anteriormente, deixou evidente a necessidade
de uma nova forma de gerência da memória principal, onde o problema da fragmentação interna
fosse reduzido e, conseqüentemente, o grau de compartilhamento da memória aumentado.
Na alocação particionada dinâmica ou variável, foi eliminado o conceito de partições de
tamanho fixo. Nesse esquema, cada programa utilizaria o espaço necessário, tornando essa área
sua partição. Como os programas utilizam apenas o espaço de que necessitam, no esquema de
alocação particionada dinâmica o problema da fragmentação interna não ocorre.
Alocação particionada dinâmica
A princípio, o problema da fragmentação interna está resolvido, porém, nesse caso, existe
um problema que não é tão óbvio quanto no esquema anterior. Um tipo diferente de fragmentação
começará a ocorrer, quando os programas forem terminando e deixando espaços cada vez
menores na memória, não permitindo o ingresso de novos programas. No caso da figura abaixo,
mesmo existindo 12kb livres de memória principal, o programa D, que necessita de 6kb de
espaço, não poderá ser carregado para execução, pois este espaço não está disposto
contiguamente. Esse tipo de problema é chamado de fragmentação externa.
26
Fragmentação externa
Existem duas soluções para o problema da fragmentação externa da memória principal. Na
primeira solução, conforme os programas terminam, apenas os espaços livres adjacentes são
reunidos, produzindo áreas livres de tamanho maior. Caso o programa C termine, uma área de
8kb será criada.
Solução para a fragmentação externa (a)
A segunda solução envolve a relocação de todas as partições ocupadas, eliminado todos
os espaços entre elas e criando uma única área livre contígua. Para que esse processo seja
possível, é necessário que o sistema tenha a capacidade de mover os diversos programas na
memória principal, ou seja, realizar relocação dinâmica. Esse mecanismo de compactação,
também conhecido como alocação particionada dinâmica com relocação, reduz em muito o
problema da fragmentação, porém a complexidade do seu algoritmo e o consumo de recursos do
sistema, como processador e área em disco, podem torná-lo inviável.
27
Solução para a fragmentação externa (b)
6.4 Swapping
Mesmo com o aumento da eficiência da multiprogramação e, particularmente, da gerência
de memória, muitas vezes um programa não podia ser executado por falta de uma partição livre
disponível. A técnica de swapping foi introduzida para contornar o problema da insuficiência de
memória principal.
Em todos os esquemas apresentados anteriormente, um processo permanecia na memória
principal até o fim da sua execução, inclusive nos momentos em que esperava por um evento,
como uma operação de leitura ou gravação. O swapping é uma técnica aplicada à gerência de
memória para programas que esperam por memória livre para serem executados, mas não há
espaço disponível na memória principal para carregar este programa. Nesta situação, o sistema
escolhe um processo residente, que é transferido da memória principal para a memória
secundária (swap out), geralmente disco. Posteriormente, o processo é carregado de volta da
memória secundária para a memória principal (swap in) e pode continuar sua execução como se
nada tivesse ocorrido.
Swapping
28
O algoritmo de escolha do processo a ser retirado da memória principal deve priorizar
aquele com menores chances de ser executado, para evitar o swapping desnecessário de um
processo que será executado logo em seguida. Os processos retirados da memória estão
geralmente no estado de espera, mas existe a possibilidade de um processo no estado de pronto
também ser selecionado. No primeiro caso, o processo é dito no estado de espera outswapped e
no segundo caso no estado de pronto outswapped.
O conceito de swapping permite maior compartilhamento da memória principal e,
conseqüentemente, maior utilização dos recursos do sistema operacional. Seu maior problema é o
elevado custo das operações de entrada/saída (swap in/out). Em situações críticas, quando há
pouca memória disponível, o sistema pode ficar quase que dedicado à execução de swapping,
deixando de realizar outras tarefas e impedindo a execução dos processos residentes.
Os primeiros sistemas operacionais que implementaram esta técnica surgiram na década
de 1960, como o CTSS do MIT e OS/360 da IBM. Com a evolução dos sistemas operacionais,
novos esquemas de gerência de memória passaram a incorporar a técnica de swapping, como a
gerência de memória virtual.
29
7. Gerência de Dispositivos de Entrada e Saída
Uma das principais funções de um SO é controlar os dispositivos de entrada e saída (E/S),
fornecendo uma interface de uso adequada. Esse capítulo mostra como o SO interage com os
dispositivos de E/S, enviando comandos e capturando suas interrupções. A gerência de E/S está
intimamente relacionada com os aspectos de hardware de um computador.
7
.1 Princípios Básicos de Hardware de Entrada e Saída
7.1.1 Dispositivos de Entrada e Saída
Um periférico (ou dispositivo de E/S) é qualquer dispositivo conectado a um computador de
forma a possibilitar a interação do computador com o mundo externo. Atualmente, existe uma
grande variedade de dispositivos, desde aqueles desenvolvidos para permitir a comunicação do
homem com o computador (teclado, mouse, monitor de vídeo, etc.) até dispositivos que
possibilitam a comunicação entre computadores (modems, placas de redes, etc.), ou ainda
aqueles destinados ao armazenamento de informações (unidades de fita, disquetes, disco rígido,
CD-ROM, etc.). Apesar dessa diversidade, existe uma razoável padronização na forma de acessar
(acionar) esses periféricos.
De acordo com o sentido do fluxo de dados entre o computador e o dispositivo, esses
podem ser divididos em periféricos de entrada, periféricos de saída, ou ainda periféricos de
entrada e saída. Outra classificação também pode ser empregada de acordo com a unidade de
transferência de dados, que pode ser bloco ou caractere (byte):
1. Em um dispositivo orientado a bloco (block devices), o armazenamento de dados e a
transferência são realizados através de blocos de tamanho fixo. As unidades de disco são o
exemplo mais comum de dispositivos orientados a bloco.
2. Os dispositivos orientados a caractere (character devices) realizam as transferências
byte a byte, a partir de um fluxo de caracteres, sem necessidade de considerar uma estrutura
qualquer. As portas seriais são exemplos de dispositivos orientados a caractere.
Existe ainda um outro tipo de dispositivo denominado pseudo-dispositivo (pseudo-devices)
que na realidade não corresponde a nenhum periférico físico. Ele é apenas uma abstração
empregada para adicionar funcionalidades ao SO, explorando a interface padronizada já existente
para o tratamento de dispositivos. É dessa forma, por exemplo, que o sistema UNIX permite o
acesso à memória principal como se fosse um disco (ramdisk), ou ainda o emprego do dispositivo
virtual.
7
.1.2 Interface, Registradores e Controladores
Um periférico é conectado ao computador através de um componente de hardware
denominado interface. Essa, por sua vez, é interconectada aos barramentos internos do
computador. Para tratar a diversidade, a complexidade, e as diferentes formas de operações de
cada periférico, as interfaces empregam no seu projeto um outro componente, o controlador, que
nada mais é que um processador projetado especificamente para realizar uma função, como, por
exemplo, controlar um disco rígido.
A CPU se comunica com o controlador através de um conjunto de registradores situados
na interface. Tipicamente, são 3 registradores: registrador de dado, registrador de status e
registrador de comando. Por exemplo, para escrever um dado em um dispositivo de saída, seriam
realizadas as seguintes operações:
1. CPU coloca o dado no registrador de dados. Isso possibilita o controlador checar se
houve algum tipo de erro durante a transmissão. Não acusando erro, a transferência é
completada.
2. CPU coloca comando write no registrador de comando. A partir daí, o controlador
comanda as ações do periférico, de forma independente da CPU, que fica livre para realizar
outras tarefas, enquanto o controlador realiza a operação com o dispositivo. No final das ações, o
controlador coloca o resultado da operação (sucesso ou falha) no registrador de status e gera uma
interrupção.
30
A função básica de um controlador é implementar um conjunto de comandos para o seu
dispositivo. O controlador vai traduzir cada ordem colocada no registrador de comando numa
seqüência específica de acionamentos eletrônicos, elétricos e mecânicos que irão realizar a
operação solicitada. Evidentemente, cada tipo de periférico necessita de um controlador diferente.
Contudo, apesar da grande variedade de dispositivos, não dá para negar que existe uma boa
padronização na forma de conectá-los ao computador e na forma de acioná-los através da CPU.
Os dispositivos de E/S, dependendo de sua interconexão física às interfaces, podem ser
do tipo serial ou paralelo. Uma interface serial é aquela em que existe apenas uma linha para
transmitir dados. Nesse caso, um byte vai ser transferido como uma seqüência de bits. Os
modems, alguns tipos de mouses e impressoras são exemplos de dispositivos seriais. Uma
interface paralela possui várias linhas para os dados, permitindo assim que vários bits sejam
transferidos simultaneamente (em paralelo) entre o dispositivo de E/S e a interface. O número de
linhas corresponde normalmente ao número de bits que compõem um byte (8 bits). As
impressoras paralelas são exemplos típicos desse tipo de dispositivo.
7
.2 Princípios Básicos de Software de Entrada e Saída
O subsistema de E/S de um SO é um software bastante complexo devido principalmente à
diversidade de periféricos que ele deve tratar. Mesmo dentro de uma mesma “classe de
dispositivos”, existe uma grande variedade, como por exemplo, placas de rede com protocolos,
tecnologias e velocidades diferentes, ou ainda discos magnéticos do tipo SCSI, IDE, EIDE,
CDROM,
etc.
O objetivo primeiro do subsistema de E/S é padronizar ao máximo a forma de acesso aos
periféricos. A camada mais inferior é composta pelo hardware dos dispositivos de E/S. Em
resumo, o hardware interage com os drivers através das interfaces físicas (paralelas ou seriais) e
seus controladores.
7
.2.1 Drivers
A camada inferior de software „Ÿ drivers de dispositivos (device drivers) „Ÿ é composta por
um conjunto de módulos, cada um responsável por implementar o acesso a um dispositivo
específico. O principal objetivo dos drivers é “esconder” as diferenças entre os vários dispositivos
de E/S, fornecendo à camada superior uma “visão uniforme” desses dispositivos através de uma
interface de programação única.
A camada de drivers é responsável por implementar as rotinas necessárias ao acesso e à
gerência de cada dispositivo. É nesse nível que o software de E/S realiza a programação de
registradores internos de controladores que compõem a interface física dos dispositivos e
implementa os respectivos tratadores de interrupção. Assim, cada tipo de dispositivo requer um
driver apropriado.
`
31
8. Gerência de Disco
Em um disco ou em uma fita pode haver milhares de arquivos. Localizar um arquivo
específico é apenas uma tarefa do sistema Operacional. O armazenamento e a recuperação de
informações é uma atividade essencial para qualquer tipo de aplicação. Um processo deve ser
capaz de ler e gravar de forma permanente grande volume de dados em dispositivos como fitas e
discos, além de poder compartilhá-los com outros processos. A maneira pela qual o sistema
operacional estrutura e organiza estas informações é através da implementação de arquivos. O
sistema operacional deve também proporcionar segurança aos dados. Arquivos com informações
críticas exigem segurança rigorosa. Se um processo gera uma solicitação para ler dados em um
setor, o Controlador do Disco deve realizar as seguintes operações:
1. Mover a cabeça de leitura e escrita para a trilha na qual se encontra o setor desejado
(Tempo de Busca).
2. Esperar que o começo do setor chegue até a cabeça de leitura (Tempo de Latência).
3. Ler o setor quando ele passar (Tempo de Transmissão).
O tempo de busca é o fator mais significativo. A cabeça tem de acelerar desde o estado de
repouso, mover-se para a trilha desejada e desacelerar novamente até o repouso. Se minimizar o
tempo de busca entre muitas solicitações de E/S, pode-se diminuir o tempo total necessário para
localizar e transmitir os dados.
Os arquivos são gerenciados pelo sistema operacional de maneira a facilitar o acesso dos
usuários ao seu conteúdo. A parte do sistema responsável por essa gerência é denominada
sistema de arquivos. O sistema de arquivos é a parte mais visível de um sistema operacional, pois
a manipulação de arquivos é uma atividade freqüentemente realizada pelos usuários, devendo
sempre ocorrer de maneira uniforme, independente dos diferentes dispositivos de
armazenamento.
8
.1 Arquivos
Um arquivo é constituído por informações logicamente relacionadas. Estas informações
podem representar instruções ou dados. Um arquivo executável, por exemplo, contém instruções
compreendidas pelo processador, enquanto um arquivo de dados pode ser estruturado livremente
como um arquivo texto ou de forma mais rígida como um banco de dados relacional. Na realidade,
um arquivo é um conjunto de registros definidos pelo sistema de arquivos, tornando seu conceito
abstrato e generalista. A partir dessa definição, o conteúdo do arquivo pode ser manipulado
seguindo conceitos preestabelecidos.
Os arquivos são armazenados pelo sistema operacional em diferentes dispositivos físicos,
como fitas magnéticas, discos magnéticos e discos ópticos. O tipo de dispositivo no qual o arquivo
é armazenado deve ser isolado pelo sistema operacional, de forma que exista uma independência
entre os arquivos a serem manipulados e o meio de armazenamento.
Um arquivo é identificado por um nome, composto por uma seqüência de caracteres. Em
alguns sistemas de arquivos é feita distinção entre caracteres alfabéticos maiúsculos e
minúsculos. Regras como extensão máxima do nome e quais são os caracteres válidos também
podem variar.
Em alguns sistemas operacionais, a identificação de um arquivo é composta por duas
partes separadas com um ponto. A parte após o ponto é denominada extensão do arquivo e tem
como finalidade identificar o conteúdo do arquivo. Assim é possível convencionar que uma
extensão TXT identifica um arquivo texto, enquanto EXE indica um arquivo executável. Na tabela
abaixo, são apresentadas algumas extensões de arquivos:
32
EXTENSÃO DEFINIÇÃO
3DS Arquivos Autodesk 3d Studio 4.
ACE/RAR/ZIP Arquivos compactados. Para descompactá-los, é preciso utilizar um
descompactador.
AIF/AIFF/AIFC Clips sonoros, eles podem ser lidos graças a um leitor multimídia.
ASP Active Server Paginas. Páginas dinâmicas produzidas no nível do servidor web. >
Navegador Web para o cliente, Servidor Web (Microsoft IIS) para os interpretar.
AVI Clipe de Vídeo, podem ser lidos em leitores multimídia
BAK Arquivo de backup. Cópia de um arquivo que um programa criou por precaução. Este tipo
de arquivo não é essencial, você pode apagá-lo.
BMP Imagem no formato Bitmap. Elas podem ser lidas por qualquer programa gráfico.
BAT Arquivos texto que contém uma lista de comandos. MS-DOS que são executados uns
depois dos outros.
BIN Arquivo que contém informações em linguagem binária.
Softwares de gravação utilizam esta extensão para as Imagens de CD.
CAB Arquivos compactados. É um formato utilizado por Microsoft para compactar as
aplicações. Eles podem ser descompactados por explicações de descompactação
recentes ou então com o utilitário CabView fornecido com o conjunto Tweak UI
CDA Arquivos para CD-áudio
CDR Desenho Corel Draw
CHK Cluster recuperado graças ao scandisk (ou chkdsk no DOS)
CUE Arquivo de Imagem de gravação
DAT São os arquivos da base do registro, eles são vitais
DBF Arquivo de Banco de dados (Data Base File / Query Database)
DLL Arquivo do Sistema
DOC Arquivo documento (Microsoft Word ou Wordpad)
EXE Arquivo executável
GIF Imagem no formato Graphic Interchange Formato
ICO Ícone
JPEG / JPG Imagem no formato JPEG
MID Arquivo sonoro no formato MIDI
MKV Arquivo Matroska Vídeo. Ele pode ser lido com um leitor vídeo depois de ter instalado os
codecs apropriados
MOV Arquivo QuickTime Movie
MP2 Arquivo áudio Mpeg
MP3 Arquivo áudio (MPEG-1 Layer 3)
MPG Filme vidéo MPEG (Motion Pictures Expert Group)
MSI Arquivo de Instalação (Microsoft Installer Package)
NFO Arquivo de informação
NRG Arquivo Imagem de CD/DVD do Nero
PPS / PPT Arquivo PowerPoint
RM Arquivo de Áudio do Real Media Player
RMVB Arquivo de Vídeo do Real Media Player
TMP Arquivo Temporário
TXT Arquivo de texto
WAV Arquivo de Som
WMV Windows Media Vídeo, arquivo vídeo alta definição
XLS Arquivo Microsoft Excel
Cada arquivo possui informações de controle denominadas atributos. Os atributos variam
dependendo do sistema de arquivos, porém alguns, como tamanho do arquivo, proteção,
identificação do criador e data de criação estão presentes em quase todos os sistemas.
Alguns atributos especificados na criação do arquivo não podem ser modificados em
função de sua própria natureza, como organização e data/hora de criação. Outros são alterados
pelo próprio sistema operacional, como tamanho e data/hora do último backup realizado. Existem
ainda atributos que podem ser modificados pelo próprio usuário, como proteção do arquivo,
tamanho máximo e senha de acesso. Na tabela abaixo, são apresentados os principais atributos
presentes nos sistemas de arquivos:
33
TAMANHO Especifica o tamanho do arquivo
PROTEÇÃO Código de proteção de acesso
PROPRIETÁRIO Identifica o criador do arquivo
CRIAÇÃO Data e hora de criação do arquivo
SENHA Senha necessária para acessar o aqrquivo
ORGANIZAÇÀO Indica a organização lógica dos registros
BACKUP Data e hora do último backup ou atualização realizado
8.2 Diretórios
Um computador moderno tem vários usuários. E cada usuário pode ter centenas de
arquivos sob seus cuidados. Logo, um sistema operacional deverá ser capaz de manter milhares
de arquivos. A estrutura de diretórios é como o sistema organiza logicamente os diversos arquivos
de diversos usuários contidos em um disco. O diretório é uma estrutura de dados que contém
entradas associadas aos arquivos onde cada entrada armazena informações como localização
física, nome, organização e demais atributos. Em outras palavras este diretório é uma lista de
todos os arquivos por nome. O diretório também contém os endereços de todos os descritores de
todos os arquivos, como mostra o exemplo da figura abaixo, que possibilitam qualquer operação
sobre eles.
Arq1
Nome do Arquivo
Arq5 5
:
:
Arq2 20
Arq8 34
Arq1 50
:
:
Diretório
Atributos
25
10
60
:
Descritor
de Arquivo
50
blocos
de dados
60
10
25
Quando um arquivo é aberto, o sistema operacional procura a sua entrada na estrutura de
diretórios, armazenando as informações sobre atributos e localização do arquivo em uma tabela
mantida na memória principal.
8.2.1 Diretórios Lineares
É a estrutura de diretório mais simples que contém um único nível. Todos os arquivos
estão contidos no mesmo diretório, como mostra a figura abaixo.
n om e
t ip o
e tc . . .
..... D i r e tó r io
A r q u iv o s
Este tipo de estrutura possui limitações significantes, quando o número de arquivos cresce
ou quando existe mais do que um usuário, como por exemplo: se todos os arquivos estão em um
mesmo diretório, eles devem possuir nomes diferentes. Como controlar isto se houver mais que
um usuário? Mesmo com um único usuário, se a quantidade de arquivos for grande, como
controlar a utilização sempre de nomes diferentes para os arquivos?
34
8.2 Diretórios Hierárquicos
Neste tipo de estrutura, cada usuário possui seu próprio diretório de nível simples,
permitindo que usuários diferentes possam ter arquivos com o mesmo nome. Assim, o sistema
possui um diretório mestre que indexa todos os diretórios de todos os usuários, como mostra a
figura abaixo.
usuário 1 usuário 2 usuário 3 Diretório
Mestre
Diretórios
dos
Usuários
Arquivos
Este tipo de estrutura é vantajosa quando os usuários são completamente independentes,
mas é desvantajosa, quando os usuários querem cooperar sobre algumas tarefas e acessar os
arquivos de outros. Alguns sistemas simplesmente não permitem que os usuários acessem outros
diretórios. Mas se o acesso for permitido, o usuário deve ser hábil em nomear um arquivo em um
diretório de um outro usuário. Os diretórios hierárquicos são também úteis quando se deseja
compartilhar arquivos em diretórios por diversos usuários “simultaneamente”.
O sistema operacional DOS e o UNIX são dois bons exemplos que adotam o diretório
hierárquico no sistema de alocação de arquivos em disco.
35
Referências Bibliográficas
ALCALDE, Eduardo. Informática Básica. Makron Books.
MACHADO, F. B., MAIA, L. P. Arquitetura de Sistemas Operacionais, 3a edição, Ed. LTC, 2002,
Rio de Janeiro.
OLIVEIRA, R. CARASSIMI A. & TOSCANI S. Sistemas Operacionais, Ed. Sagra-Luzzatto, 2004
TANENBAUM, A., Sistemas Operacionais Modernos, 5a edição, Ed. Makron Books, 1999, Rio de
Janeiro.

OS

Enviado por

Dados do documento

Descrição original:

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

OS

Enviado por

Direitos autorais:

Formatos disponíveis

ESCOLA ESTADUAL DE EDUCAÇÃO PROFISSIONAL

Você também pode gostar