Cap258 1

CAP 258 - REDES E COMUNICAÇÃO DE DADOS - SISTEMAS OPERACIONAIS
1 Sistemas Operacionais ___________________________________________________ 3
1.1 INTRODUÇÃO ____________________________________________________________ 3
1.2 Exercícios de pesquisa e fixação: ______________________________________________ 4
1.3 Kernel. Composição e Interface com Hardware__________________________________ 5
1.4 Exercícios de pesquisa e fixação: ______________________________________________ 6
1.5 Metodologia de Controle Operacional__________________________________________ 6

1.5.1 Módulo de Gerenciamento de Memória_____________________________________________ 6
1.5.1.1 - Memória Virtual ___________________________________________________________ 8
1.5.1.2 Controle por Paginação _______________________________________________________ 9
1.5.1.3 Controle por Segmentação ___________________________________________________ 10
1.5.1.4 Quadro comparatativo entre as formas de Controle ________________________________ 12
1.5.2 - Módulo de Gerenciamento de Tarefas____________________________________________ 13
1.5.2.1 - Definições _______________________________________________________________ 13
1.5.2.2 - Modos de Controle ________________________________________________________ 15
1.5.2.3 - A Comunicação entre Tarefas________________________________________________ 17
1.5.2.4 - O Ambiente Multiprocessado ________________________________________________ 19
1.5.2.5 - Série de Exercícios ________________________________________________________ 20
1.5.3 - Módulo de Gerenciamento de Periféricos _________________________________________ 21
1.5.3.1 CHIPSET: ________________________________________________________________ 21
1.5.3.2 Portas de I/O (Input/Ouput Port) _______________________________________________ 22
1.5.3.3 IRQ _____________________________________________________________________ 24
1.5.3.4 DMA (Direct Memory Access) ________________________________________________ 26
1.5.4 - Módulo de Gerenciamento de Usuários - Introdução ________________________________ 27
1.5.4.1 - Procedimento de Autenticação _______________________________________________ 29
1.5.4.2 - Interface de Comandos _____________________________________________________ 31
1.5.5 Módulo de Rede______________________________________________________________ 32
03/19/01
1
Ulisses Thadeu V Guedes
03/19/01
2
1 Sistemas Operacionais
1.1 INTRODUÇÃO
Ao ligar uma máquina passam desapercebidos um conjunto de procedimentos sequenciais.

A CPU do equipamento entra em estado de reset e busca um endereço pré definido por
hardware da própria CPU. Neste endereço deve existir algum software a ser executado que,
por sua vez, foi projetado para cumprir algumas tarefas importantes de reconhecimento do
hardware existente: quantidade de memória, capacidade e geometria dos discos, testes dos
periféricos (teclado, monitor, portas de comunicação, placas ethernet, etc). Este código
denominamos de POST.
Feito isto, e dependendo do tipo de plataforma, há a carga de partes operacionais mínimas

armazenadas em disco, ou mesmo em outra região de memória física cujo programa se
responsabilizará pela inicialização, fornecendo condições básicas para a interface. Aquela
parte mínima denominamos BIOS e este último programa denominamos Boot-Looder. As
informações do hardware e os procedimentos de acesso e controle estão armazenadas em
BIOS (Basic Input/Output System), normalmente uma memória "permanente" tipo EPROM,
ROM, PROM ou Flash.
Em plataformas compatíveis com IBM-PC, a BIOS, busca setores especiais de um dos

discos existentes. Neste setor, encontramos o Master Boot Record (MBR) que fornece
informações detalhadas sobre o particionamento daquele disco e o sistema de arquivos
utilizado, por exemplo: FAT, NTFS, HPFS, EXT2FS. Neste programa de "cabeçalho" (o
Boot-loader) contém instruções para a próxima leitura de um programa ainda mais especial
mas ainda não tão completo, denominado Kernel do Sistema Operacional que está
armazenado em disco ou em algum tipo de memória. Este, agora fará a carga dos módulos
necessários para a execução das aplicações.
03/19/01
3
Estes módulos envolvem a camada básica (kernel). As funções disponibilizadas por estes
módulos, algumas vezes escritas em linguagens de baixo nível e na maioria das vezes não
documentadas propositalmente, exigem camadas mais externas de interface. Estas
camadas são então usadas por um conjunto de aplicações auxiilares. Este conjunto (kernel,
modulos, interfaces e aplicações) denominamos de Sistema Operacional.
1.2 Exercícios de pesquisa e fixação:
1) Anote e tente descrever detalhadamente as etapas de inicialização de um micro-

computador tipo IBM-PC.
2) Tente o mesmo para uma estação de trabalho de plataforma diferente: Sun, DEC, HP e
descreva os procedimentos.
3) Discuta as diferenças e semelhanças existentes entre as plataformas.
03/19/01
4
1.3 Kernel. Composição e Interface com Hardware
Didaticamente, o Kernel pode ser estudado segundo uma estrutura modular. Cada módulo
apresenta-se como responsável pelo gerenciamento de alguma atividade: Memória,
Periféricos, Tarefas, Usuários, Rede, etc
Estes módulos implementam estratégias ou filosofias de controle, e é isto que diferencia e

caracteriza um Sistema Operacional.
Tais estratégias estabelecem recursos de software para que as aplicações tenham acesso
ao hardware do equipamento. Para entendermos isto, vejamos um exemplo do antigo
Sistema Operacional DOS 3.1 para uma plataforma IBM-PC. Naquele sistema operacional o
kernel (ou cerne) é representado pelo arquivo IBMDOS.COM e as partes associadas aos
periféricos pelo arquivo IBMIO.SYS. As funções são acessadas via interrupção usando
certos registradores como formas de passagem de parâmetros. Vamos assumir a condição
de acessar o arquivo A:\EXEMPLO.TXT.
Uma função básica de leitura é a INT 25H: A função INT 25H transfere o controle de leitura
diretamente para os drivers de periféricos. Os parâmetros são passados via registradores
AL (informado o driver A: ou B: través de números), CX (o número de setores a serem lidos),
DX (o número do setotr logico a ser lido), e DS:BX (um buffer para a transferencia dos
dados). Esta é uma função árdua para o usuário pois exige o conhecimento da posição do
arquivo no disco. Por outro lado, outras funções de Kernel foram inseridas e para facilitar o
acesso ao tal arquivo, basta chamar uma outra função, mais amigável, INT 21H com os
argumentos certos:
INT 21 - Abre um arquivo especificado pelo seu nome
Registros de Entradas:
AH = 3DH
DS:DX = Apontador para o nome do arquivo.
AL = Código de Acesso (=0 abrir para leitura, =1 abrir para escrita, =2
abrir para leitura e escrita).
Com esta última função ficou muito mais fácil a abertura do arquivo, certo? O que acontece,
realmente, pode ser "deslumbrado" usando um processo de DEBUG. Nesta condição,
vemos que esta função chamará a função INT25H após o acesso dos setores de diretório, a
busca pelo nome do arquivo e o reconhecimento do setor lógico. Incrível!!!!
Esta é a finalidade do Kernel. Disponibilizar recursos para que as interfaces "homem-

máquina" e "máquina-homem" sejam feitas de forma "amigável".
Um kernel pode ainda incluir recursos de gerenciamento de usuários. A implementação

pode ocorrer de forma distinta. Alguns sistemas permitem que usuários compartilhem a cpu
atendendo em forma de "compartilhamento de tempos" ou "timesharing" (Exemplo: Sistemas
Operacionais UNIX, VMS, MVS). Em outros o módulo de usuário está restrito à sua
03/19/01
5
autenticação para o uso de recursos perféricos, tais como discos, impressoras, modens
(exemplo: DOS, Windows NT e Novell).
Alguns sistemas operacionais apresentam recursos de interface que facilitam a iteração

homem-máquina em uma camada intermediária. Esta interface é denominada de ambiente
operacional, pois as ações tomadas pelo usuário são interpretadas e, posteriomente, tais
interfaces chamam funções operacionais de um nível mais baixo. Por exemplo, a abertura
de arquivo para a escrita ou leitura de dados. Temos aqui tres funcões distintas: A abertura
do arquivo fornece um apontador. Mas, qual parte é a responsável pela administração do
acesso ao disco, a forma de se escrever no disco, o padrão adotado, etc? Esta parte é uma
atividade do Kernel do Sistema Operacional, a da interface o Ambiente Operacional. Uma
forma bem interessante de reconhecer é questionar: "sem aquela parte consigo acessar,
executar e controlar qualquer periférico"? e esta parte for "descartável" tornando apenas a
sua "tarefa" um pouco mais árdua, ela corresponde ao Ambiente Operacional. O kernel está
abaixo dela... ajudando-a. Sem ele seu "sistema" não funciona.
Podemos dizer, portanto, que Sistema Operacional é um conjunto de aplicações

responsáveis pelo gerenciamento e monitoração da máquina .
1.4 Exercícios de pesquisa e fixação:

1) Tente identifciar outros módulos do sistema operacional que você utiliza.
2) Windows 9x é um sistema operacional ou um ambiente operacional? Onde está o Kernel
deste sistema?
3) E o Windows NT e 2000? Linux?
4) De exemplos de outros Sistemas Operacionais
1.5 Metodologia de Controle Operacional
Neste tópico analisaremos os módulos de gerenciamento separadamente, discutindo as

técnicas utilizadas sob o ponto de vista teórico, sem, ainda, tratarmos dos detalhes de
implementação. Enfocaremos as idéias envolvidas e a motivação para a inserção do
módulo.
Na análise, abordar-se-á os seguintes módulos de gerenciamento: Memória, Tarefas,

Periféricos , Usuários e Rede.
1.5.1 Módulo de Gerenciamento de Memória
Memória! Sem ela não há processamento. Só foi possível chegar aos níveis de
computabilidade atuais graças ao desenvolvimento tecnológico. Este possibilitou a redução
(em todos os sentidos) dos chips de memória. Dizemos aqui todos os sentidos pois a
velocidade de memória é medida em tempo de acesso e não em frequência de clock.
Podemos ter uma CPU ultra rápida e bancos de memória ultra lentos. O resultado?
Lentidão, atrasos, tempos de espera para a memória poder recuperar os dados. Podemos
ter também, uma CPU muito mais lenta e bancos de memória rapidíssimos. O resultado
desta comparaçao pode não ser tão óbvio assim. Podemos ter uma máquina com GigaBytes
03/19/01
6
de memória com um desempenho muito pior que outra com apenas 128MBytes numa
mesma CPU. Neste último caso, onde estaria o problema?
Sempre que a máquina realiza alguma tarefa ela precisa de memória para armazenar, em
caracter temporário, os resultados parciais obtidos. Assim, o módulo de gerenciamento de
memória é indispensável em qualquer kernel de sistema operacional.
Como sabemos, a quantidade de memória física disponível é limitada, quer pelo custo ou
por limitações de acesso do próprio hardware ou software operacional. É daí que surgem as
dúvidas: Como é possível a execução de um sistema operacional inteiro em alguns
kilobytes (ou de forma mais otimista, alguns megabytes)?
Conforme veremos adiante, as aplicações são executadas sequencialmente. Da mesma

forma que "dois corpos não ocupam o mesmo lugar no espaço" podemos adaptar para:
"duas informações não ocupam o mesmo lugar em memória". Se as aplicações são
executadas sequencialmente e não podem ocupar um mesmo endereço de memória ao
mesmo tempo, para onde as informações vão ?
Os gerentes de memória podem ser classificados em duas grandes categorias:
• Sem movimentação de processos entre memória física e disco.
• MONOPROGRAMAÇÂO, onde um único processo assume toda a

memória disponível.
• PARTIÇÕES , a memória é divida em partições e o tamanho do processo
está limitado ao tamanho de uma ou mais partições.
• COMPACTAÇÃO - o gerenciamento manipula a posição dos processos
em memória levando-os para endereços menores. Caso ocorra um
aumento do tamanho do processo durante a execução, o processo é
levado para uma região adequada.
• Com movimentação de processos entre memória física e disco;
• SWAP - Implementa o conceito de memória virtual.
03/19/01
7
1.5.1.1 - Memória Virtual
Normalmente, os aplicativos são, inicialmente, armazenados em discos. Então, poderíamos

utilizar este periférico para criarmos multiplas cópias da memória física. Este espaço em
disco poderia servir como chips de memória que seguiriam um algorítmo de troca entre
conteúdo de variáveis: onde X é a memória física e Y uma região primária do disco.
X é escrito em Y(i)
X é lido de Y(i+1)
Então Y(k) é uma Memória Virtual
Memória Virtual consiste de um mapeamento da memória física para uma região de

armazenamento (normalmente uma unidade de disco) capaz de manter as informações
temporariamente, estabelecendo, assim, uma forma de swap.
Mas, na memória física, teremos códigos que devem ser executados permanentemente para
controlar outras tarefas. A duplicidade destes códigos resultaria em disperdício. Assim, uma
opção é a divisão da memória física. Uma parte para tais códigos e dados permanentes, e
outra para as aplicações. Além da "economia de espaço" também há uma economia na
carga.
03/19/01
8
Tanto a área de códigos residentes quanto a de aplicações não consomem todo o espaço
reservado à elas. Então ainda há formas de otimizar o uso do espaço em disco.
Neste ponto surgem dois aspectos importantes: Buscando uma linearidade no

endereçamento qual é o vínculo de tal otimização? Há alguma implicação crítica quanto ao
desenvolvimento de outros aplicativos? Códigos e dados precisam ser perfeitamente
identificados? Há necessidade de alguma proteção destes códigos e dados? É o que
veremos a seguir após conhecermos as técnicas usadas para o controle ...
1.5.1.2 Controle por Paginação
Conforme visto anteriormente, estavamos mapeando metade da memória física para um

arquivo em disco. Se, de alguma forma, o módulo de gerenciamento de memória
implementasse uma continuidade na reserva de memória teríamos uma distribuição linear e
sequencial. Ou seja, quando esgotasse a capacidade de armazenamento na memória física,
o módulo reservaria partes do espaço em disco.
Nesta condição, seria melhor que a reserva fosse feita em "partes" menores, pois assim
estaríamos otimizando tal espaço. Logo, é dedutível que a unidade de memória a ser
reservada apresente um menor número de bytes. Repare que neste conceito, código, dados
e "stack" (ou pilha) podem usar a mesma parte de memória indistintamente, dependendo
do que está sendo processado. Uma pequena aplicação, por exemplo, pode requerer a
reserva de uma pequena quantidade de bytes, mas a reserva será do tamanho de um bloco.
Denominamos esta quantidade, ou bloco de memória, de página, daí o método de

CONTROLE POR PAGINAÇÃO.
03/19/01
9
O MÉTODO E CONSEQÜÊNCIAS
Cada página reservada deve identificar seu "dono" que, certamente, será um processo ou
uma thread criada (veremos as definições de thread e processo no módulo de
gerenciamento de tarefas). Esta identificação recebe o nome de PID (Process Identifition
Code, ou, Código de Identificação do Processo). Assim, para o controle destas páginas,
deve haver alguma tabela que armazenará ao número da página e o PID do "processo
proprietário". Esta tabela pode ficar em disco ou em memória reservada ao sistema.
Obviamente, o tamanho desta tabela dependerá do tamanho da página (do número de
páginas mapeáveis).
Cada sistema operacional define um tamanho de página segundo algum critério: Tamanho
de memória física, capacidade de endereçamento mínimo e máximo real da CPU, tamanho
da alocação mínima do disco, etc. Isto facilita o desenvolvimento de aplicações,
dispensando o conhecimento do tamanho do bloco pelo usuário do sistema.
No método de controle por páginação não há como identificar o que é código, dados ou
pilha, uma vez que há um mapeamento direto ou linear da memória física para o arquivo de
pagina virtual. Assim, neste caso, protegemos páginas, ou seja, se ela pode ser acessada
por outros processos, está intimamanete relacionada ao processo proprietário daquele
espaço, e não é possível proteger dados ou códigos diferenciadamente, dificultando, por
exemplo, o compartilhamento destes com outras tarefas.
As páginas reservadas podem não ser contíguas, tanto em disco quanto na seqüência de
mapeamento, o que denominamos de fragmentação. Esta fragmentação é tão prejudicial
quanto a fragmentação de arquivos em disco, implicando em maior tempo de acesso.
Alguns sistemas operacionais quando estão em tempo de espera (IDLE) executam uma
tarefa tida como (NULL). Ela, na verdade, não é tão NULL assim! Há tempo de sobra para
uma desfragmentação.
1.5.1.3 Controle por Segmentação
O Controle por Segmentação consiste em reservar memória Virtual em Segmentos

conforme a sua "classe", ou seja, em memória para códigos, dados e pilhas de forma
distinta.
Neste conceito, torna-se possível a proteção de cada segmento quanto ao

compartilhamento, por exemplo, de dados ou códigos, entre os outros processos. Cada
segmento pode assumir um tamanho qualquer, o que permite um ótimo aproveitamento de
memória e a implantação de proteções individuais. Sendo assim, os apontadores de
segmentos consistem em uma estrutura que identifica sua classe, o PID, o endereço inicial e
o seu tamanho (ou o endereço final), controle de acesso, e várias outras informações.
Uma vez que os tamanhos de reserva podem ser quaisquer, este método de controle
possibilita a fragmentação da área de memória em um nível alto.
Vejamos, abaixo, um exemplo de como ficaria a reserva de memória segundo o método de

controle por segmentação.
03/19/01
10
Assim, o controle de memória por segmentação possibilita um espaço de endereçamento de

tamanho completamente aleatório, em função do tamanho do código, do dado ou da pilha
(stack). Reparem que a fragmentação se dá por segmento e não por páginas. O
crescimento do espaço pode acontecer de forma aleatória!!! Epa! Isto implica na
fragmentação deste espaço em disco, podendo conter fragmentação de segmentos....
fragmentos sobre fragmentos. ....
Certos sistemas operacionais implementam recursos de "auto-gerenciamento" do tamanho

da memória virtual. Dá para notar que a complexidade deste gerenciamento se eleva a
medida que este "auto-gerenciamento" atende às requisições de reserva de memória. A
tabela de alocações também se expande e a memória reservada para as tarefas residentes
torna-se insuficiente, gerando partições "temporárias". Em tempo de desfragmentação,
quando existir, tentará reorganizar (realocar o posicionamento), criando um novo arquivo de
memória virtual segmentada. Uma falha no algoritimo (transição de estado de uma máquina
finita) pode gerar a perda de apontadores e, consequentemente, na perda imediata das
últimas tarefas. Epa! Numa primeira avaliação poderíamos dizer que o o problema está no
módulo de gerenciamento de tarefas, mas, na verdade, a falha está no gerenciamento de
memória.
Mais um motivo para ser adotado a técnica de Kernel modular.
03/19/01
11
1.5.1.4 Quadro comparatativo entre as formas de Controle
CONSIDERAÇÃO PAGINAÇÃO SEGMENTAÇÃO

O programador precisa ser informado da
NÃO SIM
técnica de controle uttilizada
Quantos espaços de endereçamento
1 MUITOS
existem na Técnica de controle?
O espaço de endereçamento pode
SIM SIM
exceder o tamanho da memória física?
É possível distinguir Códigos e Dados e
NÃO SIM
protegê-los separadamente?
As tabelas de tamanho variável podem
NÃO SIM
ser acomodadas sem problemas?
O compartilhamento de códigos entre
NÃO SIM
usuários é facilitado?
Permitir que programas
e dados possam ser
quebrados em espaços
Para obter um maior
de endereçamento
espaço de
Por que foi inventada esta Técnica de logicamente
endereçamento linear,
Controle de Memória? independentes e para
sem ter que ampliar a
auxiliar nas questões
memória física.
envolvendo
compartilhamento e
proteção.
"Tem algo estranho e curioso aqui!!! Parece que uma estratégia atende bem ao sistema
operacional e a outra atende bem às aplicações!!!!
Qual a melhor técnica de controle, a Paginação ou a Segmentação?
As duas técnicas tem seus prós e contras. Consideremos um sistema operacional que
empregue apenas o controle por segmentação. Em pouco tempo, a memória virtual estaria
tão fragmentada que não seria mais possivel reservar espaço contínuo de código ou dado
gerando atrasos no acesso a disco e na transferencia para a memória física. Mantendo
dados e códigos juntos, a troca de posição entre memória virtual e memória física,
agilizamos a execução da aplicação.
Por outro lado, vejamos o caso de programas que exigem uma grande área de memória
para código e stack e uma pequena área para dados, sendo estes compartilhados por
outros processos. Na técnica de paginação isto seria inviável. A segmentação seria a mais
adequada.
Assim, na verdade, os sistemas operacioais usam uma técnica mista (paginação e

segmentação, simultaneamente), ficando o Módulo de Gerenciamento de Memória como
responsável pela escolha da melhor técnica a ser empregada em função do objetivo da
tarefa. Normalmente, as aplicações ou software usados pelo sistema operacional operam
seguindo a técnica de paginação. Nada, alí, poderá ser acessado por qualquer outro
aplicativo sem o devido privilégio ou autorização. Já as aplicações de usuário, e mesmo
aquelas operacionais destinadas ao compartilhamento, devem ser tratadas usando o
03/19/01
12
método de segmentação. E como o sistema operacional sabe qual a melhor técnica? Uma
das formas é o tipo de extensão do nome do arquivo, identificadores embutidos no
cabeçalho, outra é através de parâmetros definidos em tempo de compilação ou link,
criando assim, um código de programa, ou um número mágico!!!!
Por que o programador precisa conhecer a técnica utilizada?
Para que ele prgrame prevendo a disposição de códigos e dados de forma adequada,
permitindo sua separação. Consideremos o caso de um software "device-driver". Ele atuará
diretamente no hardware acoplado ao equipamento. Os dados lidos ficarão armazenados
em buffers temporários na região do próprio código. Isto otimiza a forma de acesso
permitindo o uso de apontadores relativos, resultando numa execução mais rápida
(característica indispensável para um device-driver). Num sistema que emprega somente
segmentação, este device-driver necessitaria ser reescrito usando apontadores absolutos,
reduzindo o seu desempenho quanto ao acesso e execução . Pelo visto, algumas
aplicações exigem uma programação de baixo nível!
1.5.2 - Módulo de Gerenciamento de Tarefas
O Módulo de Gerenciamento de Tarefas é o responsável pelo controle das tarefas

computacionais.
Os sistemas operacionais podem implementar ambientes mono-tarefa, onde cada tarefa

assume toda a capacidade computacional da máquina, ou multi-tarefas (multi-tasking),
quando várias tarefas compartilham o uso de uma CPU.
Denominamos de multi-processamento quando o sistema possue várias CPUs, podendo,

cada uma delas executar uma ou mais tarefas.
Os sistemas operacionais, através deste módulo, podem implementar tarefas em forma de

PROCESSOS, THREADs ou mesmo MISTO (PROCESSO+THREAD).
Independente da forma como as tarefas são conduzidas, há situações onde a comunicação

entre as tarefas torna-se necessária. A implementação deste recurso exige, portanto,
métodos de controle adequados, sem os quais o sistema operacional entraria em regime
"morto" (DEADLOCK).
1.5.2.1 - Definições
Para evitar "confusão" de nomes adotaremos, aqui, como TAREFA a abstração (genérica)
de um procedimento em execução. Uma tarefa pode ser executada em forma de um
PROCESSO ou de uma THREAD.
Um PROCESSO apresenta as seguintes características:
• Execução de um código que se processa de forma INDEPENDENTE;

• A velocidade de execução pode ser diferente.
03/19/01
13
• Um Processo PAI pode criar processos FILHOS, e este é uma cópia dos Dados e
códigos do Processo PAI naquele instante de sua criação e, a partir deste momento,
as execuções são independentes (vidas próprias!)
• Os processos podem ser dos tipos:
“Blocked” (Bloqueáveis) - Aguardam por um evento, interrupção, mensagem…
“Suspended” (Suspensos). Um código é interrompido até que outra parte seja
processada totalmente.
Exemplos de sistemas operacionais que operam com processos: Unix-like, (Open)VMS.
Uma THREAD apresenta as seguintes características:
• Sua execução é independente, mas está vinculada ao PROCESSO pai (existência).

• Herdam características de execução do processo pai e disponibilizam para as
THREADS irmãs. (Cuidado! Alguns SOs limitam o número e o grau de parentesco na
herança dos dados, sob risco de derrubar o SO);
• Dados e códigos são compartilhados entre o PROCESSO e todas as THREADs
criadas sob ele e elas (Um arquivo aberto por uma thread está disponível para as
outras threads. Sua aplicação não precisa reabrí-lo, basta acessá-lo!!!) Exemplos: A
thread de abertura de um arquivo no processador de texto e o programa processador
de texto propriamente dito.
Exemplos de sistemas operacionais que operam com THREADS: Windows (9x, NT), BeOS,
Unix, OpenVMS.
OBS: Sistemas WINDOWS e BeOS tem como PROCESSO o próprio Sistema Operacional.
São sistemas MULTI-THREADs. Os outros operam basicamente com processos e, nestes
casos, as THREADS criadas por um determinado processo não interagem com as
THREADS criadas por um outro PROCESSO.
Recomenda-se uma leitura adicional sobre as funções responsáveis pela criação de

processos e threads de sistemas operacionais: Linux [ fork, exec(*), system ] e
Windows [CreateProcess, BeginThread, incluindo as de " compatibilidade" ].
03/19/01
14
A maior parte da literatura denomina de "processo" o que denominados aqui de TAREFA,

mas trata um porcesso como um termo genérico de MULTI-TASKING para classificar um
sistema operacional capaz de processar várias tarefas, independente destas serem
PROCESSOS ou THREADS. Por outro lado, mesmo os sistemas que são exclusivamente
MULTI-THREAD usam o termo PROCESS-ID para identificar uma determinada execução de
uma THREAD principal.
De qualquer modo, toda tarefa em execução pode ser identificada por um número (PID) e
este é usado para o controle destas tarefas.
1.5.2.2 - Modos de Controle
Em um ambiente multitarefa, observam-se 4 transições possíveis entre os 3 estados de uma

tarefa: Rodando, Bloqueado e Pronto. Considere uma tarefa em execução (rodando) para
iniciar a análise das transições.
Transição 1 - A tarefa não tem mais condições lógicas de execução; ou
Transição 2 - O escalonador de tarefas interrompe o processamento quando a tarefa já

ocupou o processador por tempo suficiente;
Transição 3 - A tarefa está pronta, aguardando sua vez, e todos as demais da fila já foram
executadas;
Transição 4 - A tarefa foi interrompida pelo escalonador devido ao término de uma atividade
crítica de outra tarefa. Ex; uma operação de I/O. Caso não exista nenhuma outra tarefa
ocupando a CPU então a transição 3 é acionada, ao invéz de 4.
Assim, o Módulo de Gerenciamento de Tarefas deve possuir uma tabela de tarefas

existentes (o PID está aí para isto!)
A distribuição das tarefas (quem pára, quem roda, quem aguarda) usa a estratégia de
ESCALONAMENTO PREEMPTIVO. Caso as tarefas sejam executadas até o seu término, a
estratégia é denominada de ESCALONAMENTO NÃO-PREEMPTIVO.
Para o escalonamento preemptivo empregam-se algoritmos de escalonamento: por tempo

(ROUND ROBIN), por prioridade, por filas baseadas em critérios como FIFO e tamanho.
03/19/01
15
Escalonamento ROUND ROBIN: A tarefa ocupa a CPU por um intervalo de tempo de

referencia denominada QUANTUM. Este tipo de escalonamento é a referência usada pelos
outros métodos. Todas as tarefas são executadas pelo período.
Escalonamento por FILAS: As tarefas são executadas em função do posicionamento da

tarefa numa fila de execução, levando em conta, por exemplo, o tamanho do código ou de
dados, ou mesmo o número de tarefas da fila. Um exemplo prático: Filas de impressão.
Escalonamento por PRIORIDADE: Este tipo de escalonamento considera a prioridade

como um de "peso" da tarefa na seleção, usando ROUND-ROBIN. Quanto maior for o peso
(a prioridade) maior é o período de tempo final de execução. A sequência é ponderada,
independentemente do tamanho do código ou de seu posicionamento em filas de execução.
Exemplo: Seja um conunto de 3 tarefas com as prioridades citadas. Ao iniciar, temos as

tarefas 1, 2 e 3 com as prioridades 3, 2 e 1 respectivamente. Uma vez que a tarefa 1 tem a
maior prioridade, ela será executada primeiro por um quantum. Findo este quantum, temos
os pesos aparentes: T1=2, T2=2 e T3=1. ela perde seu peso de execução, equiparando ao
peso da tarefa 2 que deterá o uso da CPU , pois T1 acabou de ser executada e T2 está
mais próxima da fila. Finda a tarefa T2, os pesos aparentes são: T1=2, T2=1, T3=1. T1 tem
um maior peso residual e volta para a execução. Em seguida, T1=1, T2=1, T3=1. Como T1 e
T2 tem maior peso real que T3, e T1 acabou sua execução, então ela, T2, deve ter a vez , o
que reduz a zero sua prioridade aparente. Agora, T1 e T3 detêem a mesma priodidade
aparente, mas T1 tem peso real maior. Neste impasse, T1 ganha a execução e perde em
prioridade aparente. Agora, finalmente, T3 ganha a execução e todas as tarefas estão com
prioridade aparente nula. O escalonador reinica as prioridades aparentes com os valores de
prioridade reais reiniciando o ciclo de execução.
03/19/01
16
Reparem que neste exemplo deparamos com condições de igualdade de pesos aparentes e
adotamos uma estratégia de decisão baseada nas prioridades reais. O que aconteceria caso
T3 executasse um código de região crítica? A estratégia adotada seria a mais adequada?
O emprego individual destes algoritmos não geram um escalonamento muito eficiente e

certas decisões podem levar a DEADLOCK . O emprego de algorítimos mistos, além de
contornar problemas de DEADLOCK, apresentam maior desempenho, justiça na execução,
throughput e tempo de resposta, ou seja, as características de um bom algorítimo de
escalonamento.
1.5.2.3 - A Comunicação entre Tarefas
Em ambientes multi-tarefas não é dificil depararmos com situações que exigem a

comunicação entre tarefas. Para proporcionar este recurso, o Módulo de Gerenciamento de
Tarefas explora as características do ambiente de processamento, thread ou processo.
Como dito, uma das características de THREAD é o compartilhamento de áreas de

estruturas/objetos. Assim, a forma mais adequada de comunicação entre tarefas deste tipo
(THREAD) é o de COMPARTILHAMENTO DE MEMÓRIA. Em PROCESSOS o ambiente
deve proporcionar recursos especiais, denominados de IPC (InterProcess Communication).
Nada impede que tais procedimentos sejam usados tanto por THREADS quanto por
PROCESSOS.
A comunicação entre tarefas podem acontecer utilizando uma ou mais técnicas abaixo:
- MAILBOX
- INTERRUPÇÃO
- EVENTOS
MAILBOX - Estabelece-se a criação de um buffer em alguma unidade de armazenamento

(disco ou memória). Estas áreas se assememham às áreas de Memória Compartilhada,
porém com restrições de acesso como um arquivo com registro único de tamanho variável.
A escrita ou leitura nestes pseudo-arquivos são rápidas, mas estão sujeitas à CONDIÇÃO
DE CORRIDA caso a escrita seja feita por mais de uma tarefa. Numa filosofia semelhante à
MAILBOX encontramos o IPC (InterProcess Communication).
INTERRUPÇÃO - Utiliza-se o chamado VETOR DE INTERRUPÇÃO. Embora apresente

problemas em casos de plataformas multi-processadas, esta técnica ainda é bem utilizada
em plataformas compativeis com IBM-PC.
EVENTOS - É um contador de eventos. Um gerador de sinais (um valor) consulta uma

tabela em função de ocorrências do sistema. Um vetor de eventos é mantido em memória,
contendo os ID#s das tarefas que fazem o acesso a aquele evento. Ao ser gerado o evento,
todas as tarefas que o utiliza são informadas executando o código apontado. Esta forma de
comunicação se assemelha aos SEMÁFOROS. Vejam no Linux, Windows, etc, as funções
que tratam de semáforos (SIGNAL, SIGACTION, etc). Tanto em SEMÁFOROS quanto em
EVENTOS, podem ocorrer situações onde as tarefas em execução permanecem
bloqueadas. Esta situação denominamos de DEADLOCK.
03/19/01
17
OS PROBLEMAS ENVOLVIDOS NA COMUNICAÇÃO ENTRE PROCESSOS/THREADS,

NOS CRITÉRIOS DE DECISÃO E NA EXECUÇÃO DAS TAREFAS QUE LEVARAM ÀS
TÉCNICAS CITADAS:
Cada uma destas formas de comunicação apresentam "problemas" e/ou dificuldades de

implementação. Vejamos o caso de COMPARTILHAMENTO DE MEMÓRIA onde os dados
são compartilhados entre duas ou mais tarefas que acessam a mesma região de memória.
Considere duas tarefas acessando a mesma posição de memória de modo que o valor final
seja diferente depedendo da ordem de execução das tarefas envolvidas. Denominamos este
"fenômeno" de CONDIÇÃO DE CORRIDA. Em certas condições, a Condição de Corrida
torna-se um "problema", não um "fenômeno"!
Uma alternativa para o problema é estabelecer o acesso na forma de EXCLUSÃO MÚTUA,

ou seja, enquanto uma tarefa utiliza uma variável compartilhada, ela se torna proprietária
dela e daquele código impedindo que tal variável seja usada por outras tarefas. Mas como
implementar? Analisemos algumas propostas:
a) INIBIÇÃO DAS INTERRUPÇÕES - Uma vez que o escalonamento de tarefas pode ser
feito via interrupção, a inibição destas poderia ser considerada? É alternativa válida, mas
não é apropriada. As interrupções devem ser usadas para a execução de outras tarefas.
Teríamos uma tarefa com 100% de CPU e as outras tarefas ficariam em espera por
tempo indeterminado, o que não é recomendável!
b) USO DE VARIÁVEIS DE TRAVAMENTO - Poderíamos usar uma ou mais variáveis para

sinalizar um travamento? Pode ser, mas isto não vai eliminar a condição de corrida.
c) ESTRITA ALTERNÂNCIA - E se a sinalização de alguma variável fosse tipo alternada?

Hummm!!!! Neste caso um processo que entra na sua região crítica (parte de um
programa que leva à condição de corrida) altera o valor de uma variável. Qualquer outra
tarefa tem que testar o valor daquela variável, antes de entrar na sua região crítica. Por
outro lado, quando as tarefas são PROCESSOS, poderemos ter velocidades diferentes
implicando em maiores dificuldades para contornar o problema de Condição de Corrida.
d) SOLUÇÃO DE PETERSON - O algoritimo implementa uma variável de travamento e

uma variável complementar, denominada variável de tensão. Esta foi a primeira solução
em software.
e) INSTRUÇÃO TSL (TEST & SET LOCKED) - É uma opção aplicável para ambiente com
mais de uma CPU e dotados de instrução TSL. Ao ser ativada, esta instrução toma o
barramento de memória tornando-o exclusivo do processo ativo até que ele termine a
execução da instrução. Este tipo de solução pode levar ao problema de PRIORIDADE
INVERTIDA, onde um processo de alta prioridade permanece inativo eternamente.
Então não tem solução para isto? Que tal o uso de dois SEMÁFOROS, uma variável inteira
que conta o número de sinais armazenados para uso futuro. A atualização deles feita por
uma rotina de sistema que não pode sofrer interrupção. Caso a plataforma seja multi-
procesada, complementa-se com TSL.
"Ninguém disse, nem pode dizer, que explorar recursos operacionais é simples! Antes de
explorá-los precisamos saber se existem! Se existirem então vamos buscar 'como' . Se não
existem ou selecionamos outra plataforma e SO ou implementamos o recurso. Só aí
03/19/01
18
poderemos medir a complexidade! A dificuldade de implementação dependerá das

bibliotecas de funções disponíveis. Em determinados sistemas operacionais, o uso de
funções existentes pode ser tão complexo quanto a sua implementação, com exagero e
tudo!!! Eis aqui uma condição para a escolha de um sistema operacional em relação ao
objetivo final da máqina/equipamento."
As soluções propostas até agora são aplicáveis para todos os sistemas?
Não exatamente. Para os sistemas com processamento paralelo foi criada uma primitiva de
alto nível chamada MONITOR para ajudar no sincronismo das tarefas. Esta diretiva pode ser
chamada pelas tarefas sempre que precisarem. Alocando as regiões críticas dentro do
monitor não haverá possibilidade de mais de uma tarefa executar sua região crítica
simultaneamente. Tomemos agora um ambiente envolvendo processamento distribuído.
Para estes, a solução proposta se baseia em troca de mensagens. Nestes sistemas há mais
um problema: podemos perder as mensagens. Neste caso, podemos "contornar" o problema
usando métodos tais que o envio e o recebimento delas sejam GARANTIDAS.
1.5.2.4 - O Ambiente Multiprocessado
Analisaremos 3 implementações de um ambiente multiprocessado quanto ao acoplamento

usado:
1) Uma plataforma com várias CPUs;

2) Mais de uma plataforma configuradas em CLUSTER
3) Plataformas interligadas via rede.
Estas implementações apresentam as seguintes características:
CARACTERÍSTICAS DO SISTEMA + DE 1 CPU CLUSTER REDE

BOOT Da CPU juntas separadas separadas
Falhas De Cpu juntas separadas separadas
Localização Das Cpus singular ou adjacente Mesma sala Distantes
Gerenc. Do Domínio E Segurança Única Única Múltipla
Sistema De Arquivos Integrado Integrado Separado
Capac. De Expansão Limitada Muito Grande Muito Grande
Acoplamento Forte Moderado Fraco
O ACOPLAMENTO pode ser:
FRACO: Cada processador executa uma cópia separada de Sistema Operacional da

plataforma (local)
MODERADO: Cada processador executa sua própria cópia de sistema operacional, mas
um deles coordena certas atividades dos outros processadores.
03/19/01
19
FORTE: Os processadores envolvidos compartilham uma mesma cópia do sistema

operacional.
Sob o ponto de vista de execução dos Códigos, classificamos em multiprocessamento

simétrico ou assimétrico. No processamento simétrico, todos os processadores
executam todo o código. No assimétrico, o código completo fica sob responsabilidade de
um único processador, mas os outros processadores podem executar algumas partes.
Detalhes de Ambiente Multi-processado serão vistos no curso de Processamento de Alto

Desempenho (PAD).
1.5.2.5 - Série de Exercícios
1) Desenvolver um programa para imprimir uma string fixa e um indice de um contador i

que deve variar de 1 a 10 usando linguagem C. Ex: string "Programa 1, %d".
2) Crie um segundo programa, idêntico ao primeiro, com outra string " Programa 2, %d".
3) Modifique o programa 1 para executar o programa 2 antes de entrar para o looping de

impressão, usando a função da família exec (execl, execlp, execle, execv, execvp). A
parcela do código do programa 1 foi executada?
4) Substitua a função exec* do ex. 3 pela função "system" e compare os resultados com a
questão 3. A parte do código de impressão do programa 1 foi executada?
5) Substitua a função exec* do ex. 3 pela função "fork" e compare os resultados com as
questões anteriores. Como ficou a impressão dos resultados?
6) Crie um programa que envie uma mensagem qualquer, fornecida como argumento de
chamada, para um outro programa usando as funções adequadas. Verifiquem as
funções "msgsend" e "msgrcv".
7) Fazer um programa que imprima a hora do sistema, permaneça inativo por um tempo de
5 segundos e depois imprima novamente a hora. Para confirmar a parada de 5
segundos, imprima o instante da parada e reinicio.
8) Fazer um programa que mostre o seu tempo de processamento após um looping de

leitura e/ou escrita em disco de um arquivo de 1MB. Repare que é o tempo de
processamento (tempo de uso da CPU) e não o tempo de relógio.
9) Criar um programa que use o recurso de memória compartilhada. Use a função mmap e
correlatas. Para usar este recurso no Linux, informe-se sobre a quantidade de memória
física da máquina (ex: 64Mbytes). Em tempo de boot entre com: "linux mem=63m" (retire
1 Mega. Este espaço será utilizado como área de memória compartilhada.)
10) Repita as questões de 1 a 7 usando uma máquina com o sistema operacional diferente
(se vc usou Linux, agora use o Windows, e vice-versa).
03/19/01
20
1.5.3 - Módulo de Gerenciamento de Periféricos
O Módulo de Gerenciamento de Periféricos é responsável pelo controle dos periféricos e

pela coordenação da interface entre as aplicações e os periféricos existentes ou instalados
em um computador. Basicamente, ele gerencia e controla o acesso aos "device-drivers"
(interfaces de periféricos de baixo nível) associados a cada periférico, considerando a
disponibilidade para o acesso.
Evidentemente, não há uma "filosofia única" de implementação do sistema de I/O. Ela está
fortemente associada aos recursos disponíveis por hardware (CHIPSET da placa e dos
periféricos) usados nas plataformas
O Módulo de Gerenciamento de Periféricos deverá proporcionar a proteção na transferência

de dados, responder pelo "status" do periférico quanto a sua disponibilidade, estabelecer
prioridade na transferencia, e na conversão necessária quando alguma operação de I/O for
solicitada. Em outras palavras, o Módulo de Gerenciamento de Periféricos está numa
camada tal que possa conversar com os device-drivers, servindo como uma interface e
compondo uma árvore de periféricos. Assim, um sistema operacional controla não só o
funcionamento de periféricos mas o acesso a eles. Exemplos práticos são os "sistemas
operacionais" Windows 9x (95, 98), Windows NT e Linux. No Windows 9x qualquer
aplicação pode acessar um periférico diretamente, podendo fazer um by-pass nas funções
do Kernel. Já nos S.O.s Windows NT e Linux este acesso dependerá de "permissões
especiais" concedidas pelo kernel (interferencia do administrador do sistema) segundo
certas "normas" de prioridade e privilégios.
Como os dados podem ser transferidos de um periférico para a memória ou vice-versa?
Usamos, ao longo deste texto certos termos como CHIPSET, Irq, Portas de I/O e DMA. Siga
os links!!!
1.5.3.1 CHIPSET:
O controle de todos componentes que constituem um computador jamais poderia ser feito
usando somente a CPU central. Que controle são esses? Tempo de resfresh de RAM,
prioridade de resposta, controle dos barramentos de expansão (ISA, EISA, PCI, etc), portas
de comunicação, controladores de disco, teclado, vídeo, som, etc. Para se ter uma idéia da
importância dos co-processadores e dispositivos auxiliares, se construíssemos um
computador dotado de CPU de 700 MHZ sem eles, este computador teria um desempenho
muitas vezes pior que um PC XT rodando em 4 Mhz (exagerando, é claro!).
Para se ter uma idéia das atividades desempenhadas por estes componentes consulte os
ítens existentes na BIOS de seu computador e leia os manuais que acopanham a placa
mãe.
Certos parâmetros fornecidos alí afetam, consideravelmente, o desempenho de todo um

sistema operacional. Alguns SOs, tidos como PnP (Plug aNd Play), buscam informações
03/19/01
21
sobre os recursos disponíveis na BIOS. Outros fazem sua própria varredura (pesquisa)
acionando recursos do CHIPSET em busca de novos periféricos realocando parâmetros
para proporcionar o máximo desempenho em atividades críticas (acesso a disco, vídeo,
placas de som, etc), tais como: Capacidade de DMA, acesso a disco em multi-setores,
tamanho das memórias cache nos níveis 1 e 2, etc.
OUT OF TOPIC
Falando em PnP, seu computador IBM-PC desktop é mesmo do tipo PnP? E o Notebook? E um
Apple? O que é preciso para um sistema ser, realmente, PnP?
Dizemos que um sistema é PnP quando o trio BIOS, PERIFÉRICO e SISTEMA OPERACIONAL é
PnP e trabalham integrados.. Linux é PnP? Se não, como ele é capaz de detectar os periféricos
existentes? E o NT é PnP? E o Windows 2000?
Por que destas perguntas? Muitas vezes a configuração de certos periféricos e sistemas são
traumáticas justamente por "considerar um recurso disponível", enquanto que, na verdade, não está!
A solução exige uma interferencia manual. Uma placa de rede quando está aos cuidados do PnP
pode não ser explorada adequadamente (modo de operação, velocidade, etc). Drivers deficientes
podem não permitir que se explore tais recursos, mesmo que o periférico seja PnP.
Busquem informações sobre um BUG da CPU Intel, conhecido como F00F (F, zero, zero, F) e como
os fabricantes de sistemas operacionais resolveram o problema.Por ser um problema antigo esta
informação pode estar indisponível
Já que estamos estudando periféricos, há mais algum bug de data (como o Y2K)? Para quando e por
que?0
1.5.3.2 Portas de I/O (Input/Ouput Port)
A transferência de dados entre um periférico e a memória depende de certos recursos da

CPU (instruções e hardware). Plataformas que empregam CPUs tipo CISC (Complex
Instruction Set Computing), que possuem intruções tipo IN/OUT, podem utilizar métodos de
decodificação usando o barramento de dados. As plataformas usando CPUs tipo RISC
(Reduced Instruction Set Computing), ou as que não possuem este tipo de instrução,
utilizam o barramento de endereços.
OBS: O fato de uma CPU ser RISC não implica, necessariamente, que ela possua
um menor número de instruções. Processadores PowerPC 601 tem mais instruções
que um processador Pentium!
No primeiro caso, decodificação do barramento de dados, o código usa instruções tipo

IN/OUT e um número que identifica a porta.
03/19/01
22
No segundo caso, a decodificação usando o barramento de endereços, a PORTA seria

equivalente a um detrminado endereço de memória. Temos, assim, a transferência se dá
com um movimento do dado de uma posição de memória (PORTA) para outra (MEMÓRIA
FÍSCA) através de uma instrução tipo MOV.
Algumas CPUs tem instruções de movimentação (MOV) do dado de um endereço de

memória para outro. No caso de funções IN/OUT, o dado segue para a CPU e depois segue
para a memória. Neste dois casos a CPU está diretamente envolvida com a transferência,
consumindo ciclos em estado de espera (DEV READY) para completar a operação. Com
isto temos duas filosofias de decodificação que permitem a transferência de dados entre um
periférico e a memória central:
OBS: NADA IMPEDE QUE UMA PLATAFORMA QUE USE UMA CPU TIPO CISC
TRABALHE USANDO BARRAMENTOS DE ENDEREÇOS.
Há duas filosofias de (de)codificação:
03/19/01
23
Na decodificação por Endereços, o Módulo de Gerenciamento de Periféricos estará usará

recursos implementados no Módulo de Gerenciamento de Memória que deve tratar de
proteger o acesso a aquele endereço. No método de IN/OUT, estas instruções devem ser
protegidas pelo kernel, usando recursos da própria CPU.
Exemplos:
1) Consideremos um sistema com decoficação por endereço, onde 0x1234567F é o

endereço (hexadecimanl) de acesso ao vídeo para leitura, 0x12345680 é o endereço
para a porta de escrita de dado, e 0x123456781 é o endereço para o acesso ao status
ou controle. Estes endereços, por exemplo, também devem ser gerenciados pelo módulo
de memória. Este deve negar todo e qualquer pedido de reserva de memória destes
endereços feita por quaisquer outras aplicações para evitar conflitos.
2) Consideremos um certo periférico apresentando as portas via IN/OUT: 0x2300 até

0x23FF reservadas. Da mesma forma, nenhum outro periférico pode utilizar deste
endereço pois, com certeza, haverá conflito. Neste caso, o Módulo de Gerenciamento de
Memória não tem qualquer informação sobre o fato, e algum outro módulo deve
estabelecer o controle.
Resumindo: As portas de entrada/saida são específicas de um periférico. O seu uso é

restrito e controlado pelo Módulo de Gerenciamento de Periféricos, e, dependendo do caso,
com o conhecimento e auxílio do Módulo de Gerenciamento de Memória. O controle, então,
pode ser via CPU (instruções de I/O).
1.5.3.3 IRQ
Uma forma de interromper o processamento é informar à CPU através de um sinal de

hardware, um IRQ ou Intrrupt Request. Este sinal pode ser enviado diretamente ou por
outros dispositivos, tais como um controlador programável de Interrupção - Programmable
Interrupt Controler - PIC - que pode estar embutido no CHIPSET da plataforma, cartão
auxiliar do periférico, ou instalado na placa mãe de forma isolada.
03/19/01
24
Qualquer periférico que use uma (ou mais) destas linhas de interrupção, normalmente
periférico de entrada, pode usufruir deste recurso para tomada de decisão (um evento, por
exemplo), ou sinalizar que a tarefa incumbida a ele terminou e os dados estão prontos para
serem "aproveitados".
Para exemplificar, considere o funcionamento do mouse. Um "mouse" é dotado de sensores

de movimento e botões. Qualquer que seja o movimento está gerando uma interrupção e
esta dispara a execução de um procedimento de leitura. Ou seja, temos uma interrupção em
hardware disparando um software. Acontece o mesmo com o teclado: cada tecla
pressionada é uma interrupção que está sendo atendida. Vamos sentir isto na "carne"? Faça
um programa que armazene em um vetor de inteiros com 100000 elementos (ou mais),
tendo como valor o próprio índice. Antes de iniciar o loop, chame uma função de sistema
que inicie um contador de tempo do processo (um process-time e não um elapsed-time!). Ao
terminar o loop, imprima o valor gasto pelo processo. Rode o programa, algumas vezes,
sem mexer em nada e anote os valores de tempo. Repita as execuções movendo o mouse.
Anote e compare os tempos.A diferença entre eles está por conta das atividades que
correspondem às interrupções do mouse. Se voce roda Windows NT então execute o
TaskManager, deixe o sistema entrar em modo de repouso. Como saber isto? Verifique o
Uso de CPU. Ele deverá cair para um valor muito baixo. Agora movimente o mouse sem
apertar qualquer botão. Observou? O nível de Uso da CPU cresceu. O que ela estaria
fazendo?
Num micro-computador PC, cada interrupção de hardware está associada a execução de

um procedimento identificado por elemeto de um vetor, uma INT (algum valor). São os
chamadas vetores de interrupção. Estes vetores estão armazenados em RAM, e seus
códigos em parte na BIOS e/ou em RAM, podendo ser substiuídos ou implementados pelo
sistema operacional (captura de IRQs). Alguns sistemas operacionais disponibilizam tais
vetores como funções de serviço de sistema (System-Services) ou em forma de
procedimentos (rotinas) servindo de interface para as aplicações através de bibliotecas de
desenvolvimento. Estas funções variam com a plataforma, mas sempre estão lá!!!
E se esta interrupção fosse acionada por um relógio interno a cada XX milisegundos?

Hummmm!!! Podemos aproveitar esta interrupção para estabelecer um outro tipo de
controle, caso este valor não seja muito grande!!!
Há certas situações onde o procedimento que está sendo executado precisa sinalizar algum
evento e gerar uma interrupção de hardware não mascarada ou NMI (Interrupção não-
mascarada). Está aqui uma outra excelente fonte de implementação de alguns serviços do
Kernel para controle de atividades.
Que tal esta outra? Seu computador tem um relógio RTC (Real-Time Clock). Este relógio
tem despertador. Se tem este recurso voce pode usá-lo para sincronizar o relógio do
sistema. Onde se aplica? Programas de Tempo Real (Real-Time Simulation). Normalmente,
os sistemas operacionais apresentam uma taxa de sincronismo entre estes relógios em
tempos, relativamente, grande demais para este tipo de aplicação.
03/19/01
25
1.5.3.4 DMA (Direct Memory Access)
O Acesso Direto à Memória é um recurso (capacidade) proporcionado pela arquitetura dos

computadores ao permitirem que os dados, ao serem transferidos, sejam enviados
diretamente de um periférico para a memória (ou vice-versa) ou memória para memória.
Com este recurso a CPU não se envolve com a transferência de dados, aumentando a
velocidade de operação .
Normalmente, a transferência de dados entre a memória e componentes (inclue-se a CPU)

ocorrem em função da capacidade de transferência quantificadas em número de bytes.
Numa operação de I/O normal, por exemplo, os dados podem ser transferidos byte a byte ou
em palavra a palavra. Num modem, principalmente nos mais antigos, a transferencia se dá
byte a byte. Consequentemente, os tempos de CPU envolvidos no processo de
transferência são elevados. Em sistemas uni-processados (uma única CPU) e ambiente
Multi-tarefa, como visto anteriormente, a tarefa executada pode prender a atividade de
processamento até que uma resposta de um periférico seja recebida. É o que chamamos de
REGIÃO CRÍTICA.
Para reduzir o bloqueio de acesso podemos utilizar recursos de DMA, desde que disponível.
Neste caso a transferência de dados se dá diretamente entre a memória e periféricos. Os
dados são transferidos em blocos (ou bancos) e não mais byte a byte. Enquanto há a
transferência tanto a CPU quanto demais periféricos não envolvidos com a ação e presentes
no barramento são impedidos de acessarem o barramento de memória (modo suspenso),
porém, o tempo é muito menor. Através de recursos de cache de nível 2 (cache externo), a
CPU poderá continuar com a execução de algum código, mesmo que o barramento de
memória principal esteja suspenso.
As operações de DMA, quando disponíveis, são muito utilizadas pelo módulo de

gerenciamento de memória na desfragmentação das páginas e acesso ao disco. Para este
último caso, o disco deve posuir alguma memória física (RAM) para a transferência em
bloco. Atualemente, sistemas de disco ATA (IDE) exploram este recurso. Isto é, há muito
tempo, explorado por controladoras e discos SCSI.
03/19/01
26
O recurso de DMA é uma característica de hardware. Se um periférico disponibiliza este

recurso isto indica que aquele periférico implementa, de alguma forma, um armazenamento
temporário em RAM própria (buffers internos).
1.5.4 - Módulo de Gerenciamento de Usuários - Introdução
Os sistemas operacionais também são classificados quanto ao número de usuários, em

Mono-Usuário ou Multi-Usuário.
O Módulo de Gerenciamento de Usuários é responsável pelo controle dos perfis de trabalho

e autenticação dos usuários da máquina.
Dizemos que um sistema é mono-usuário quando é concedido um único assento de

usuário quer seja localmente ou remotamente, devidamente autenticado. Sistema multi-
usuário é quando o sistema permite vários assentos simultâneos com todos os recursos de
um usuário no console. Ao fornecer o assento, o S.O. disponibiliza sessões time-sharing,
concedendo: interpretador de comandos (interface gráfica ou não), métodos de controle de
acesso (ACLs), e compartilhamento da(s) CPU(s) entre usuários. Cada usuário representará
uma tarefa específica. As aplicações executadas pelo usuário representam tarefas filhas
daquela primeira.
Sob todos estes aspectos, um sistema Windows NT Server é mono-usuário, mas um

Windows NT Terminal Server um sistema Multi-Usuário. Quer uma prova? Instale o serviço
de TelnetD disponível no Windows NT 4 Resource Kit. Você estará instalando o serviço
Telnet, e um outo módulo denominado Remote Console Manager. Até aí tudo nos leva a
crer que estamos implantando os módulos necessários para atender o requisito de Multi-
Usuário. Todos os serviços habilitados, faça um Telnet desta máquina para ela mesma. Use
o endereço localhost (127.0.0.1). O usuário recebe o prompt, mas não consegue executar
"qualquer" comando. Tem dúvida? Neta sessão recém criada, faça um novo telnet para a
mesma máquina. Bimba!!!!! Nada acontece!!! Por que? Porque não foi disponibilizado um
"shell" completo, um ambiente necessário para um usuário usufruir dos recursos de CPU. O
módulo instalado implementa partes de um recurso e não "o recurso". Quer mais outro
exemplo: Estabeleçca a conexão com o Windows NT via linha serial. Você recebeu algum
prompt de login? Repita, agora, o mesmo procedimento para uma máquina multi-usuário.
Que máquina? Um Unix-like, OpenVMS, ou mesmo um Windows NT Terminal Server. Agora
você terá quantas sessões desejar com todos os recursos "normais" disponíveis para um
usuário local que esteja no console ou acessando remotamente.
No Windows 2000 Enterprise (equivalente ao NT Server) há a opção de instalação do

módulo multi-sessão. Se isto não fosse previsto em Kernel não seria possível sua execução.
O Módulo de Gerenciamento de Usuários é composto por procedimentos de autenticação -

responsável pela verificação do usuário na abertura da sessão (LOGIN), entrega de um shell
de comandos, avaliação das quotas permitidas, gerenciamento e controle das tarefas
permitidas para o usuário. Estas informações são definidas em tempo de abertura da conta
e armazenadas em arquivos seguindo uma política própria (arquivo de senhas - sistemas
Unix-like e outros e arquivo de registros - família do Windows-Like).
OBS Como podem observar, alguns sistemas operacionais permitem a instalação de

recursos de kernel de forma modular. Porém, alguns recursos apresentam uma
03/19/01
27
maior desempenho quando fazem parte do kernel. No caso citado do Windows NT

4.0, implica que o kernel não está preparado para a inserção do módulo Multi-
Usuário, e o procedimento de Remote Console Manager ainda está incompleto! Para
entender melhor, vamos comparar a estrutura do Windows NT versão 3.5 com a
versão do NT 4.0. Na versão 3.5, algumas funções básicas da parte de vídeo eram
inseridas, exclusivamente, através de módulos externos. Na versão 4.0 daquele
operacional, foram inseridos procedimentos básicos no kernel o que possibilitou um
ganho sensível no desempenho, melhor flexibilidade e melhor aproveitamento de
recursos que a versão mais antiga.
03/19/01
28
1) Faça o teste de múltiplas sessões em outros sistemas operacionais: OS/2, HP-UX, AIX,
OpenVMS (tem uma conta disponível para testes em OpenVMS, Linux e Windows NT em
máquinas com acesso controlado. Informe-se com o professor).
1.5.4.1 - Procedimento de Autenticação
Autenticação de usuário basea-se na verificação de credenciais para a concesão de direitos,

ou autorizações na exploração de recursos computacionais. Uma das formas de
autenticação consiste na verificação das credenciais username/password fornecidas pelo
usuário em tempo de login. Métodos especiais de autenticação, tais como: reconhecimento
de voz e autenticação por assinatura eletrônica (passphrase), tem sido testadas
apresentando um maior nível de segurança.
A autenticação por credenciais tipo username/password consiste na comparação das

credenciais fornecidas pelo usuário em tempo de login e aquelas registradas num arquivo
específico em tempo de criação da conta do usuário. Por segurança, a senha é armazenada
de forma cifrada e o arquivo deve ser protegido, impedindo o acesso por usuários não
autorizados. O arquivo de contas de usuários detém, além das credenciais, informações
complementres tais como: tamanho de senha, validade desta, número de identificação do
03/19/01
29
usuário, o número de indentificação do grupo que ele pertence, shell utilizado, diretório
inicial, etc.
A senha é cifrada segundo algum método. Uma forma seria o emprego de one-way-hash-
function. O usuário fornece a senha em modo aberto (plain/text) e esta função gera a
informação na forma cifrada (ciphertext), comparando-a com aquela armazenada em
arquivo. A alteração de um bit na senha fornecida gerará um valor completamente diferente.
Isto quer dizer que a entrada de uma senha no formato cifrado não gerará o mesmo valor.
Uma referencia recomendada para se iniciar na área de criptografia é o documento do PGP
disponível em www.pgp.com. As referências, abaixo, são recomendadas por Philip
Zimmermann, criador do PGP no tutorial da aplicação.
• “Cryptography for the Internet,” por Philip R. Zimmermann. Scientific American,

October 1998. Este artigo é tutorial de vários protocolos e algoritimos de criptografia.
• “Privacy on the Line,” Whitfield Diffie and Susan Eva Landau. MIT Press; ISBN:
0262041677. Este livro é a apresentação da história e politica de segurança ao
usarmos a criptografia e meios de comunicação.
• “Network Security: Private Communication in a Public World,” by Charlie Kaufman,
Radia Perlman, and Mike Spencer. Prentice Hall; ISBN: 0-13-061466-1.
• “Applied Cryptography: Protocols, Algorithms, and Source Code in C,”by Bruce
Schneier, John Wiley &Sons; ISBN: 0-471-12845-7. É um bom livro para começar
entender criptografia.
• “Handbook of Applied Cryptography,”byAlfredJ.Menezes,PaulC.van Oorschot, and
Scott Vanstone. CRC Press; ISBN: 0-8493-8523-7. Depois do Schneier, leia este!
• “Differential Cryptanalysis of the Data Encryption Standard,” by Eli Biham and Adi
Shamir. Springer-Verlag; ISBN: 0-387-97930-1. É um livro excelente para
apresendermos sobre a técnica criptoanálise.
As técnicas de criptografia não se limitam à autenticação. Elas são usadas para a

transferência de dados de forma cifrada através de um meio inseguro. Isto não significa,
"transferência de forma eternamente segura". Um texto cifrado não significa que ele jamais
será quebrado. É uma questão de tempo e do método de criptografia utilizado! O estudo dos
métodos para quebrar o texto cifrado denominamos de criptoanalise, ou seja converter um
chiper-text para plain/text. Esta conversão pode variar de milisegundos a 12 milhões de
vezes a idade do universo com os recursos computacionais disponíveis em 1997
(Recordando... em Janeiro e 1997, um fabricante processadores anunciava um novo
processador de 200 MHz. Agora, no ano 2000 este mesmo fabricante anunciou seu
processador de 1GHz. Há 20 anos, o clock dos processadores deste fabricante era de 4,77
MHz, aproximadamente, 210 vezes menor). Mas, e daqui a 20 ou 30 anos?
“If all the personal computers in the world—260

As técnicas e recursos
million—were put to work on a single PGP-
computacionais que hoje levam todo
encrypted message, it would still take an estimated
aquele tempo, poderão consumir
12 million times the age of the universe, on average,
poucos segundos em alguns anos.
to break a single message.”
Então, com estes dados, os
--William Crowell, Deputy Director, National
sistemas operacionais devem incluir
Security Agency, March 20, 1997.
em seus módulos de autenticação
Arquivo IntroToCrypto.pdf por Phil Zimmerman
funções cada vez mais sofisticadas.
03/19/01
30
----------------------------------------------------
OUT OFF TOPIC, BUT NOT SO MUCH!
Existem certos aplicativos disponíveis por aí (na Internet) que são usados para quebrar
senhas. Para terem uma idéia, em alguns minutos, com um destes aplicativos rodando em
um Pentium de 300 Mhz em um certo sistema operacional, foi possível capturar e quebrar
mais de 10 senhas de usuários. (não quebrou mais pois foi desativado!). Isto indica que o
método usado para o armazenamento das senhas ou transmitidas pela rede (mesmo
cifradas) não apresenta uma cifragem adequada (o que chamamos de criptografia fraca).
Este é o motivo pelo qual os métodos de autenticação implementam recursos de senhas
com tempo de expiração. A atualização de senhas é fundamental para a segurança de
um sistema e de qualquer rede, e qualquer que sejam os Sistemas Operacionais das
máquinas envolvidas. Nos cursos seguintes, veremos que NÃO EXISTE SISTEMA
OPERACIONAL SEGURO.
1.5.4.2 - Interface de Comandos
Em função do perfil selecionado na geração da conta ou na escolha feita pelo usuário em

tempo de login, o sistema operacional pode disponibilizar recursos de shell para o usuário.
Este "shell" (ambiente de comando) pode ser em linha de comando (prompt) permitindo a
execução de aplicativos sem requintes gráficos, ou mesmo um ambiente gráfico, quer seja
como "casca" ou aplicações gráficas dedicadas.
Na forma dedicada , o shell disponibiliza grande parte dos comandos de forma gráfica
executando-os em processos separados com a saída direcionada para aquele assento ou
terminal do usuário. Na forma de "casca", o usuário habilita as opções desejadas e o shell
executa o procedimento em linha de comando, com os parâmetros de entrada selecionados
pelo usuário, em um outro processo/thread.
Sob este aspecto, analise os sistemas operacionais disponíveis, observando as tarefas

criadas.
Interfaces gráficas exigem uma grande interação entre os periféricos e processadores

envolvidos (memória video, memória e CPU da placa mãe, CPU de vídeo, etc). Como viram,
a migração de um módulo gráfico externo para o kernel (arquiteturas NT 3.51 e NT 4.0)
trouxe ganhos tanto em desempenho quanto na disponibilidade de recursos.
A interface de comandos também pode oferecer um ambiente puramente no modo texto.

Nestes casos, temos a ação de interpretadores de comandos. Estes estabelecem a forma
de interação entre o usuário com todo o sistema. Estes interpretadores podem ou não dispor
de comandos internos. Quando um usuário requisita a execução de algum comando
inexistente, o interpretador tem a responsabilidade de buscar tal comando seguindo um
caminho especificado em variáveis de ambiente (tipo PATH), ou em regiões (diretórios) pré-
definidos. Por exemplo: Certas versões do (li)(U)n(i)(u)x armazenam aplicações de sistema
03/19/01
31
no diretório /usr/bin. Numa versão de outro fabricante as mesmas aplicações (até mesmo
com nomes idênticos), estão num diretório diferente.
1.5.5 Módulo de Rede
O recurso de estabelecer a conexão entre máquinas não é recente. Sempre foi uma
preocupação desde que se comprovou a viabilidade dos computadores. O módulo de Rede
veio, portanto, propiciar este requinte, hoje, "tão comum".
Quando falamos na interigação de máquinas vem à tona um questões tais como: a

finalidade, os protocolos e as aplicações. Vamos observar alguns Sistemas operacionais e
seus objetivos iniciais:
O DOS, por exemplo, prevê um modulo de rede baseado nos protocolos denominado
NetBEUI e NETBIOS. O objetivo era interligar máquinas de pequeno porte compartilhando
arquivos, impressoras, tranferencia de mensagens, mas não de CPU. As atividades de CPU
deveriam ser isoladas. Por outro lado previa-se alguns recursos de CPU quando se tratava
da execução de tarefas dedicadas (gerenciamento, controle das filas de impressão, etc),
uma vez que grandes máquinas poderiam participar destas atividades. A proposta da IBM (e
o sistema Operacinoal MVS e protocolo SNA). Neste caso o módulo de gerenciamento de
rede prevê tais recursos disponibilizando serviços de sistema compatíveis.
Outros fabricantes buscaram um Sistema Operacional para atender uma demanda de

terminais. Estes terminais não detinham capacidade de decisão. Tais tarefas eram
transferidas para uma máquina central. Apesar disto, buscava-se uma certeza da chegada
dos datagramas entre os terminais e a máquina central. Previa-se, também, a possibilidade
de unir redes. Com estes (dentre outros) objetivos foi construido o SIstema Operacional
Novel e os protocolos IPX/SPX/SNAP.
Outros fabricantes, ainda, buscavam um sistema de alta confiabilidade voltado para os

problemas de tempo-real, grande escalabilidade, desempenho mesmo considerando um
grande número de usuários e poucos recursos de memória. Nascia, destes requisitos, o
Sistema Operacional VMS usando um protocolo denominado DECnet.
O sistema Operacional precessor de quase todos era o Unix. Quando foi criado buscava
atender um grande número de usuários conectados via terminais "burros" ligados através de
linhas seriais e protocolos de baixo nível. Em 1972 iniciavam estudos de um protocolo que,
mais tarde viria revolucionar e interligar o mundo: o TCP/IP. O objetivo era possibilitar a
execução remota, impressão, compartilhamento de arquivos, mensagens, etc, entre
máquinas e entre redes diferentes.
Como estamos vendo, a implementação do módulo de rede tem um acoplamento muito forte
com os objetivos do sistema operacional, e é o responsável por disponibilizar funções e
serviços de sistema que propiciem a interligação das máquinas.
Por ser um módulo que exige desempenho, ele requer uso exaustivo de memória e
programações otimizadas para minimizar o uso de CPU. Quanto maior for a velocidade
usada no meio físico (meio usado para interligar as máquinas), mais rápido deve a CPU,
barramentos internos, acesso à memória, enfim o hardware envolvido. A chegada de um
03/19/01
32
datagrama na interface de rede dispara uma sequencia de eventos (Interrupções, sinais,

etc) e uso de recursos disponibilizados pelos outros módulos.
O módulo de rede, como se observa, é um grande cliente dos outros módulos e o provedor
de serviços (funções básicas) para as aplicações de rede.
Com a internet iniciou-se uma corrida para a inserção do protocolo TCP/IP nos módulos de
rede. E foi justamente aí que começaram os problemas de segurança, exigindo atualização
constante deste módulo (especificamente, das funções de serviço que ele proporciona).
Vamos nos aprofundar neste módulo de rede, com o objetivo de entender o "fenomeno
rede", suas aplicações, serviços, operação, características, etc no próximo capítulo
03/19/01
33
03/19/01
34

Cap258 1

Enviado por

Dados do documento

Título 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

Cap258 1

Enviado por

Direitos autorais:

Formatos disponíveis

CAP 258 - REDES E COMUNICAÇÃO DE DADOS - SISTEMAS OPERACIONAIS

1 Sistemas Operacionais ___________________________________________________ 3

1.1 INTRODUÇÃO ____________________________________________________________ 3

1.2 Exercícios de pesquisa e fixação: ______________________________________________ 4

1.3 Kernel. Composição e Interface com Hardware__________________________________ 5

1.4 Exercícios de pesquisa e fixação: ______________________________________________ 6

1.5 Metodologia de Controle Operacional__________________________________________ 6

1.5.1.1 - Memória Virtual ___________________________________________________________ 8

1.5.1.2 Controle por Paginação _______________________________________________________ 9

1.5.1.3 Controle por Segmentação ___________________________________________________ 10

1.5.1.4 Quadro comparatativo entre as formas de Controle ________________________________ 12

1.5.2 - Módulo de Gerenciamento de Tarefas____________________________________________ 13

1.5.2.1 - Definições _______________________________________________________________ 13

1.5.2.2 - Modos de Controle ________________________________________________________ 15

1.5.2.3 - A Comunicação entre Tarefas________________________________________________ 17

1.5.2.4 - O Ambiente Multiprocessado ________________________________________________ 19

1.5.2.5 - Série de Exercícios ________________________________________________________ 20

1.5.3 - Módulo de Gerenciamento de Periféricos _________________________________________ 21

1.5.3.1 CHIPSET: ________________________________________________________________ 21

1.5.3.2 Portas de I/O (Input/Ouput Port) _______________________________________________ 22

1.5.3.3 IRQ _____________________________________________________________________ 24

1.5.3.4 DMA (Direct Memory Access) ________________________________________________ 26

1.5.4 - Módulo de Gerenciamento de Usuários - Introdução ________________________________ 27

1.5.4.1 - Procedimento de Autenticação _______________________________________________ 29

1.5.4.2 - Interface de Comandos _____________________________________________________ 31

1.5.5 Módulo de Rede______________________________________________________________ 32

Ao ligar uma máquina passam desapercebidos um conjunto de procedimentos sequenciais.

Feito isto, e dependendo do tipo de plataforma, há a carga de partes operacionais mínimas

Em plataformas compatíveis com IBM-PC, a BIOS, busca setores especiais de um dos

1.2 Exercícios de pesquisa e fixação:

1) Anote e tente descrever detalhadamente as etapas de inicialização de um micro-

1.3 Kernel. Composição e Interface com Hardware

Estes módulos implementam estratégias ou filosofias de controle, e é isto que diferencia e

INT 21 - Abre um arquivo especificado pelo seu nome

Esta é a finalidade do Kernel. Disponibilizar recursos para que as interfaces "homem-

Um kernel pode ainda incluir recursos de gerenciamento de usuários. A implementação

Alguns sistemas operacionais apresentam recursos de interface que facilitam a iteração

Podemos dizer, portanto, que Sistema Operacional é um conjunto de aplicações

1.4 Exercícios de pesquisa e fixação:

1.5 Metodologia de Controle Operacional

Neste tópico analisaremos os módulos de gerenciamento separadamente, discutindo as

Na análise, abordar-se-á os seguintes módulos de gerenciamento: Memória, Tarefas,

1.5.1 Módulo de Gerenciamento de Memória

Conforme veremos adiante, as aplicações são executadas sequencialmente. Da mesma

Os gerentes de memória podem ser classificados em duas grandes categorias:

• Sem movimentação de processos entre memória física e disco.

• MONOPROGRAMAÇÂO, onde um único processo assume toda a

• Com movimentação de processos entre memória física e disco;

• SWAP - Implementa o conceito de memória virtual.

1.5.1.1 - Memória Virtual

Normalmente, os aplicativos são, inicialmente, armazenados em discos. Então, poderíamos

Memória Virtual consiste de um mapeamento da memória física para uma região de

Neste ponto surgem dois aspectos importantes: Buscando uma linearidade no

1.5.1.2 Controle por Paginação

Conforme visto anteriormente, estavamos mapeando metade da memória física para um

Denominamos esta quantidade, ou bloco de memória, de página, daí o método de

1.5.1.3 Controle por Segmentação

O Controle por Segmentação consiste em reservar memória Virtual em Segmentos

Neste conceito, torna-se possível a proteção de cada segmento quanto ao

Vejamos, abaixo, um exemplo de como ficaria a reserva de memória segundo o método de

Assim, o controle de memória por segmentação possibilita um espaço de endereçamento de

Certos sistemas operacionais implementam recursos de "auto-gerenciamento" do tamanho

Mais um motivo para ser adotado a técnica de Kernel modular.