Estudo de caso: Windows NT

628 views
440 views

Published on

Published in: Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
628
On SlideShare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
0
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Estudo de caso: Windows NT

  1. 1. UNIVERSIDADE FEDERAL DE PELOTASINSTITUTO DE FÍSICA E MATEMÁTICADEPARTAMENTO DE INFORMÁTICABACHARELADO EM CIÊNCIA DA COMPUTAÇÃOESTUDO DE CASO: WINDOWS NTJerônimo Medina MadrugaLeonardo Lobo da LuzMauro Sérgio Cardoso KadeTrabalho de pesquisa apresentado na disciplina deSistemas operacionais 2 do Curso de Bacharelado emCiência da Computação, Instituto de Física eMatemática, Universidade Federal de Pelotas. Professor:Prof. Gil Medeiros2007
  2. 2. Lista de FigurasFigura 1: Componentes do Sistema de E/S...........................................................................14Figura 2: Rotinas primárias de drivers de dispositivos.........................................................16Figura 3: Abrindo um objeto de arquivo...............................................................................21Figura 4: Enfileirando e completando uma requisição de E/S..............................................25Figura 5: Mapeando Páginas Virtuais para estruturas de página físicas...............................33Figura 6: Mapeando Visões em uma Seção..........................................................................38Figura 7: Section Object........................................................................................................39Figura 8: Antes do copy-on-write.........................................................................................42Figura 9: Depois do copy-on-write.......................................................................................43Figura 10: Espaço de Endereçamento Virtual.......................................................................45Figura 11: Tabela de Páginas Conceitual..............................................................................47Figura 12: Esquema de tradução de endereço virtual para endereço físico em arquiteturasIntel.......................................................................................................................................54Figura 13: Principais funções API Win32 para gerenciamento da memória virtual.............59Figura 14: Representação de um processo como objeto.......................................................61Figura 15: Representação de uma Thread como um objeto..................................................62Figura 16: Tabela de prioridades do Windows 2000............................................................67Figura 17: Principais funções API Win32 para funções de arquivos....................................70Figura 18: Tabela Mestre de Arquivos NTFS.......................................................................73Figura 19: Registro da MFT para um arquivo......................................................................75Figura 20: Registro da MFT para um pequeno diretório......................................................79Figura 21: Visão geral de um FSD local...............................................................................80Figura 22: Operação de FSD remoto....................................................................................81Figura 23: Criptografia de Arquivos.....................................................................................84
  3. 3. SumárioAPRESENTAÇÃO.................................................................................................................51. HISTÓRICO.......................................................................................................................61.1 MS-DOS........................................................................................................................61.2 Windows.......................................................................................................................61.3 Windows NT.................................................................................................................71.4 Windows 2000..............................................................................................................82. GERENCIAMENTO DE E/S...........................................................................................112.1 Principais objetivos do sistema de E/S .......................................................................112.2 Componentes do Sistema de E/S.................................................................................122.2.1 Gerenciador de E/S..................................................................................................152.2.2 Drivers de Dispositivo..............................................................................................152.2.2.1 Estrutura de um Driver..........................................................................................162.2.3 Gerenciador de PnP (Plug-and-Play).......................................................................172.2.4 Gerenciador de Cache..............................................................................................182.3 Estruturas de Dados de E/S.........................................................................................192.3.1 Objetos de Arquivo..................................................................................................192.3.2 Objetos de Driver e Objetos de Dispositivo.............................................................222.3.3 Pacotes de Requisição de E/S..................................................................................222.4 Processamento de E/S.................................................................................................232.4.1 Tipos de E/S.............................................................................................................232.5 Suporte a RAID...........................................................................................................262.6 Plug-and-play..............................................................................................................262.7 Suporte a multiprocessamento....................................................................................272.8 Recuperação de falha de energia.................................................................................273. GERENCIAMENTO DE MEMÓRIA..............................................................................293.1 Memória Virtual..........................................................................................................303.2 Gerenciando a Memória..............................................................................................343.2.1 Estados de uma página virtual..................................................................................353.2.2 Memória Compartilhada..........................................................................................363.2.2.1 Section Object.......................................................................................................393.2.3 Proteção de Memória...............................................................................................413.3 Implementação............................................................................................................443.3.1 Mecanismos de Paginação.......................................................................................463.3.2 Políticas de Paginação..............................................................................................493.3.3 Gerenciamento da memória física............................................................................513.3.4 Tradução de Endereços............................................................................................533.3.5 Tratamento de Falta de Página.................................................................................553.3.6 Descritores de Endereço Virtual..............................................................................563.4 Chamadas ao Sistema..................................................................................................584. GERÊNCIA DE PROCESSOS.........................................................................................604.1 Caracterização de Jobs, Processos, Threads e Fibers..................................................604.2 Técnicas de comunicação............................................................................................634.3 Técnicas de sincronização...........................................................................................644.4 Criação de Processos e Threads..................................................................................65
  4. 4. 4.5 Escalonamento............................................................................................................665. SISTEMA DE ARQUIVOS..............................................................................................685.1 Conceitos Fundamentais do NTFS..............................................................................685.2 Chamadas de API........................................................................................................705.3 Estrutura do Sistema de Arquivos...............................................................................715.4 Arquitetura do Driver de Sistema de Arquivos...........................................................795.5 Compressão de Arquivos............................................................................................825.6 Criptografia de Arquivos.............................................................................................83REFERÊNCIAS BIBLIOGRÁFICAS..................................................................................87
  5. 5. APRESENTAÇÃOEste trabalho tem como objetivo realizar uma análise em um dos sistemasoperacionais mais difundidos no mundo, o Windows NT. Em um primeiromomento, faremos uma abordagem da história do desenvolvimento dessesistema, revelando suas raízes e mostrando sua evolução ao longo dos anos.Após, abordaremos os componentes mais relevantes na estrutura do sistemaoperacional em estudo: o gerenciamento de entrada e saída, gerenciamento dememória, gerenciamento de processos, e gerenciamento de arquivos, comparadocom os elementos previamente estudados na disciplina.
  6. 6. 1. HISTÓRICOEste capítulo tem como objetivo representar os avanços em sistemasoperacionais e o contexto histórico que levaram ao desenvolvimento daarquitetura do desenvolvimento do Windows NT. Daremos enfoque aospredecessores do Windows NT, o MS-DOS e Windows, citando suascaracterísticas, vantagens e desvantagens. Após, entraremos mais afundo noprojeto do Windows 2000, um dos representantes mais recentes do Windows NT,mostrando suas inovações tecnológicas e os princípios de desenvolvimento domesmo.1.1 MS-DOSEm 1981, a IBM produzia o IBM PC utilizando o processador 8088. Essecomputador vinha com sistema operacional de 16 bits monousuário chamado MS-DOS (Microsoft Disk Operational System). Esse sistema operacional consistia em8 KB de código residente na memória e foi modelado de forma similar ao CP/M,um sistema operacional pequeno para os processadores de 8 bits 8080 e Z80.Dois anos depois, uma nova versão, o MS-DOS 2.0, foi lançada, contendo umprocessador de linha de comando e com diversas características semelhantes aoUNIX. Com o passar do tempo foram sendo lançada novas versões de acordocom a evolução dos computadores, que agregavam novas características, mascontinuava basicamente sendo um sistema orientado a linha de comando[TANENBAUM, 2001].1.2 WindowsTendo como inspiração a interface de usuário do Apple Lisa, a Microsoftdecidiu dar ao MS-DOS uma interface gráfica, a qual foi chamada de Windows. OWindows 1.0 foi lançado em 1985, mas não chegou a ter sucesso, assim comoseu sucessor Windows 2.0. A popularização começou com o Windows 3.0 e seus
  7. 7. derivados, mas é importante salientar que nenhuma dessas versões iniciais doWindows eram realmente sistemas operacionais, eles eram interfaces gráficaspara o usuário trabalhar em cima do MS-DOS, que ainda gerenciava a máquina eo sistema de arquivos. Todos os programas rodavam no mesmo espaço deendereçamento e um defeito em qualquer um deles poderia causar uma panegeral no sistema.Esse cenário começa a mudar com o Windows 95, onde apesar do MS-DOS ainda estar intrínseco no sistema, grande parte do sistema operacional já eragerenciado pelo sistema, além de já contar com características de um sistemamais maduro, como memória virtual, gerenciamento de processos emultiprogramação. Como herança do MS-DOS, o Windows 95 ainda continhapartes do código sendo composta por código assembly de 16 bits e ainda usava osistema de arquivos do MS-DOS.O sucessor do Windows 95, o Windows 98, ainda continha o MS-DOS,agora na versão 7.1, mas já tinha um sistema de arquivos novo. Ele também tinhauma maior integração entre a Internet e o desktop do sistema. O Windows 98 tinhaainda dois problemas crônicos, fora a presença do legado do MS-DOS: o códigodo kernel não era reentrante, o que ocasionava problemas na execução dediversos processos que utilizassem estruturas de dados do kernel e o fato quehavia uma parte do espaço de endereçamento virtual que era compartilhada portodos os processos, além do kernel, assim um defeito em um programa poderiaafetar todo o sistema.Após veio o Windows Me (Windows Millenium Edition), que eraessencialmente o Windows 98, com a correção de alguns dos defeitos e comalguns novos recursos relativos aos dispositivos que despontavam na época e aaplicativos multimídia.1.3 Windows NTEm 1988, a Microsoft decidiu desenvolver um sistema operacional para adécada de 1990. O MS-DOS tinha sido desenvolvido para hardware antigo, e
  8. 8. assim os modos de utilização do mesmo começaram a ficar rapidamenterestritivos e obsoletos, como o suporte a modo monousuário unicamente,arquitetura de 8 e 16 bits com um suporte rústico para múltiplos processos, semproteção de memória entre eles. A alternativa da época, o OS/2, foi uma tentativade aumentar o escopo de uso, mas continha grandes fragmentos de código emassembly para arquitetura CISC monoprocessada, e assim não poderia evoluirpara usufruir das vantagens dos novos processadores RISC e das ferramentas deproteção à memória presentes nos processadores subseqüentes da Intel.Também durante esse tempo, várias pesquisas acadêmicas sobre sistemasoperacionais começaram a ser divulgadas [BACON, 2003].Para desenvolver esse novo sistema, Dave Cutler, que foi um importantedesenvolvedor do sistema operacional VMS, foi contratado pela Microsoft, com ointuito de liderar a equipe que iria desenvolver o sistema que seria chamadoposteriormente de Windows NT (Windows New Technology), que seria o primeiroWindows a funcionar totalmente 32 bits, tendo foco tanto para o mercadoempresarial quanto para os computadores domésticos. . A primeira versão foibatizada Windows NT 3.1, que apesar de ser superior tecnicamente à versão doWindows baseada no MS-DOS que existia no momento, não chegou a ter muitosucesso devido ao fato que o sistema era mais pesado e ainda não havia grandegama de aplicativos 32 bits.Após, foram lançadas sucessivas atualizações para o sistema NT, até serlançada uma nova versão em 1996, o Windows NT 4.0, que tinha a mesmainterface que consagrou o Windows 95, em conjunto com poder, segurança econfiabilidade, e assim esse sistema teve uma aceitação muito maior que seupredecessor. Sendo quase totalmente escrito em C, o Windows NT eraextremamente portável, e com isso ele rodava em diversas outras plataformas, emcontraste ao Windows 95 e seus descendentes, que rodavam somente naArquitetura X86 da Intel [TANENBAUM, 2001].1.4 Windows 2000
  9. 9. O Windows 2000 foi o nome do sucessor do Windows NT 4.0, e tinha comoobjetivo ter a confiabilidade da família NT com a interface do Windows 98. OWindows 2000 manteve diversas características do Windows NT, sendo umsistema totalmente 32 bits (mas mantendo compatibilidade com aplicativos 16 bits)focado para quase todo o mercado de computadores: de laptops a estaçõesmultiprocessadas.O Windows 2000 teve diversos princípios utilizados para seudesenvolvimento, entre eles podemos citar:• Extensibilidade: para encarar as constantes mudanças na demandado mercado, o Windows 2000 foi desenvolvido numa estruturamodular baseada em objetos, o que permitiu que funções comuns,como controle de acesso a recursos, fossem separadas das funçõesespecificas. Assim drivers de dispositivos pode ser carregados edescarregados dinamicamente.• Portabilidade: tendo como objetivo poder ser portado para outrasarquiteturas com o menor numero de mudanças possível, o Windows2000 foi quase totalmente escrito em C e C++, sendo assim alinguagem assembly se restringe às camadas dependentes dehardware.• Escalabilidade: o Windows 2000 permite que as aplicações exploremtodo o potencial do hardware, tendo suporte paramultiprocessamento e grande espaço de endereçamento físico.• Robustez: o sistema deve ser capaz de proteger-se contra errosinternos, defeitos e ataques externos. O sistema de proteção previneque nenhum programa corrompa o sistema operacional ou outraaplicação.• Compatibilidade: o Windows 2000 mantém compatibilidade com osaplicativos desenvolvidos para as versões mais antigas de sistemasoperacionais da Microsoft.• Segurança: O Windows 2000 tem segurança classe C2 para multi-usuário e sistemas comerciais, que consiste em um sistema de login
  10. 10. protegido por senha, o sistema operacional rodando em modoprotegido, espaços de endereçamentos protegidos e cotas derecursos.• Performance: O sistema tem de ser rápido ao responder para ousuário [BACON, 2003].
  11. 11. 2. GERENCIAMENTO DE E/SEste capítulo tem por objetivo descrever as funcionalidades, os componentes eo funcionamento básico do sistema de gerência de E/S do Windows NT, assimcomo a interação entre esses diversos componentes que compõe o sistema deE/S.2.1 Principais objetivos do sistema de E/SAlguns dos objetivos principais do sistema de gerência de E/S do Windows NTsão:• Tornar o processamento de E/S rápido tanto para arquiteturas monoquanto multiprocessadas.• Utilizar mecanismos de segurança para proteger recursoscompartilhados.• Prover serviços de E/S para as interfaces Win32, POSIX e OS/2.• Permitir que drivers de dispositivo sejam instalados e desinstalados deforma dinâmica, garantindo sua configuração automática, assim comodo hardware a ser adicionado ou removido do sistema.• Provê suporte a vários sistemas de arquivo, entre eles a tabela dealocação de arquivos (FAT), o sistema de arquivo de CD-ROM (CDFS),o formato de disco universal (UFS), e o sistema de arquivos do WindowsNT (NTFS).A seguir, uma descrição detalhada dos componentes do sistema de gerênciade E/S e a maneira pela qual eles atuam para atingir tais objetivos.
  12. 12. 2.2 Componentes do Sistema de E/SO Windows NT consiste em uma série de componentes que, em conjunto,oferecem diversos serviços de E/S periféricos atuantes em um sistema decomputador. Tais componentes fazem parte da camada executiva do WindowsNT. A figura 1 a seguir ilustra todos esses componentes.• O gerenciador de E/S é responsável pelos acessos ao sistema dearquivos, gerenciamento de cache, drivers de dispositivo e drivers derede. Ele determina quais sistemas de arquivo instaláveis sãocarregados, e gerencia os buffers para as requisições de E/S. Eletrabalha com o gerenciador de MV (Máquina Virtual) para prover umsistema de E/S mapeado em memória, e controla o gerenciador decache do NT. O gerenciador de E/S suporta operações síncronas eassíncronas, provê timeouts para os drivers, e possui mecanismos paraum driver chamar outro.• O gerenciador de cache oferece serviços de cache para todos oscomponentes em controle do gerenciador de E/S, e trabalha próximo aogerenciador de MV (Máquina Virtual). O tamanho da cache mudadinamicamente, de acordo com a quantidade de memória livredisponível no sistema.• Um driver de dispositivo tipicamente oferece uma interface de E/S paraum tipo de dispositivo em particular. Drivers de dispositivo recebemcomandos roteados para eles pelo gerenciador de E/S, sendo enviadospara os dispositivos que eles gerenciam, informando ao gerenciador deE/S quando esses comandos terminarem.• O gerenciador PnP (Plug-and-Play) atua em conjunto com o gerenciadorde E/S e com um driver de dispositivo chamado driver de barramentopara guiar a alocação dos recursos do hardware de forma segura eresponder satisfatoriamente às adições e/ou remoções de componentesde hardware. O gerenciador PnP e os drivers de barramento são
  13. 13. responsáveis por carregar um driver de dispositivo quando umdeterminado componente é detectado.• O gerenciador de força atua em conjunto com o gerenciador de E/S paraguiar o sistema, assim como os drivers de dispositivo, através detransições de estados de força ou de energia.• O registro serve como uma base de dados que armazena umadescrição básica dos dispositivos de hardware presentes no sistema,assim como inicialização e configuração de um driver.• Arquivos INF, designados pela extensão .inf, que são arquivos deinstalação de drivers. Esses arquivos são a ligação entre um dispositivode hardware particular e o driver que assume o controle do dispositivo.• A camada de abstração de hardware (HAL – Hardware AbstractionLayer) oferece API’s que escondem as diferenças entre as plataformasdos drivers. Na prática, o HAL é um driver de barramento para todos osdispositivos da placa-mãe do computador que não são controlados poroutros dispositivos.
  14. 14. Figura 1: Componentes do Sistema de E/SMuitas operações de E/S não envolvem todos os componentes descritosacima. Uma típica requisição de E/S começa com uma aplicação executando umadeterminada função de E/S (por exemplo, ler dados de um disco rígido) que éprocessada por um gerenciador de E/S, um ou mais drivers de dispositivo, e oHAL.No Windows NT, diferentes threads realizam E/S em arquivos virtuais. Osistema operacional abstrai todas as requisições de E/S como se fossemoperações em um arquivo virtual, escondendo o fato de que o objetivo de umaoperação de E/S pode não ser um dispositivo estruturado de arquivo. Essaabstração generaliza uma interface de aplicação para os dispositivos. Um arquivovirtual, por sua vez, refere-se a qualquer fonte ou destino para a E/S que é tratadacomo se fosse um arquivo comum. Todos os dados que são lidos ou gravados sãoconsiderados como um simples fluxo de bytes dirigidos para esses arquivosvirtuais. Aplicações em modo usuário chamam funções específicas, que por suavez chamam funções internas do sistema de E/S para ler de um arquivo, escrever
  15. 15. em um arquivo, e/ou realizar outras operações. O gerenciador de E/S enviadinamicamente essas requisições dos arquivos virtuais para o driver de dispositivoapropriado.Nas seções seguintes, os componentes serão descritos com maisprofundidade. Primeiramente será visto o gerenciador de E/S e, logo após, osdrivers de dispositivo, assim como as estruturas de dados do sistema de E/S.2.2.1 Gerenciador de E/SO gerenciador de E/S é responsável pelos acessos ao sistema de arquivos,gerenciamento de cache, drivers de dispositivo e drivers de rede. Ele determinaquais sistemas de arquivo instaláveis são carregados, e gerencia os buffers paraas requisições de E/S. Ele trabalha com o gerenciador de MV (Máquina Virtual)para prover um sistema de E/S mapeado em memória, e controla o gerenciador decache do NT. O gerenciador de E/S suporta operações síncronas e assíncronas,provê timeouts para os drivers, e possui mecanismos para um driver chamar outro[SILBERSCHATZ, 1998].O gerenciador de E/S converte as requisições que recebe em um formatopadrão chamado IRP (I/O Request Packet). Ele então encaminha o IRP para odriver correto para processamento. Quando a operação termina, o gerenciador deE/S recebe o IRP do driver que recentemente executou uma operação, e completaa requisição.2.2.2 Drivers de DispositivoUm driver de dispositivo funciona como a ponte necessária entre o gerenciadorde E/S e os componentes do sistema de E/S.Entre alguns dos tipos de drivers de dispositivo encontram-se:
  16. 16. • Drivers de sistema de arquivo: aceitam requisições para arquivos.• Drivers do Windows NT: atuam em conjunto com os gerenciadores deforça e PnP do Windows NT, quando requisitados.• Drivers de dispositivo virtuais: utilizados para emular aplicações de 16bits do MS-DOS.2.2.2.1 Estrutura de um DriverO sistema de E/S controla a execução dos drivers de dispositivo. Os drivers dedispositivo consistem em uma série de rotinas que são chamadas para processaros vários estágios de uma requisição de E/S. A figura abaixo (Figura 2) ilustraalgumas dessas rotinas.Figura 2: Rotinas primárias de drivers de dispositivos
  17. 17. O gerenciador de E/S executa uma rotina de inicialização do driver(initialization routine), que é denominada DriverEntry, quando carrega o driver nosistema operacional.Um driver que suporta Plug-and-Play implementa uma rotina de adição dedispositivo (add-device routine). O gerenciador de PnP manda uma notificação aum driver através dessa rotina. Ela também permite que um driver aloque umobjeto de dispositivo para representar o dispositivo.Rotinas de envio (Set of dispatch routines) são funções vitais que um driverde dispositivo oferece. Alguns exemplos são abertura (open), fechamento (close),leitura (read), escrita (write) e outras capacidades relacionadas a dispositivos,sistema de arquivos ou suporte a rede. Quando chamado para realizar umaoperação de E/S, o gerenciador de E/S gera um IRP e chama um driver através deuma rotina de envio de driver.Um driver pode usar uma rotina de início de E/S (start I/O routine) para iniciaruma transferência de dados para ou de um dispositivo. Essa rotina é definidasomente em drivers que contam com o gerenciador de E/S para uma serializaçãoIRP. O gerenciador de E/S serializa IRP’s para um driver garantindo que o driverprocesse somente um IRP por vez.Quando um dispositivo causa uma interrupção, o despachador de interrupçãodo kernel transfere o controle para uma rotina chamada serviço de interrupção(interrupt service routine – ISR).Uma rotina de serviço de interrupção DPC (interrupt-servicing DPC routine)realiza muito do trabalho envolvido no tratamento de uma interrupção dedispositivo após a ISR executar. A rotina DPC executa a nível de dispositivo, paraevitar bloqueio de outras interrupções desnecessariamente.2.2.3 Gerenciador de PnP (Plug-and-Play)O gerenciador de PnP é o componente principal envolvido no suporte àshabilidades do Windows NT de reconhecimento e adaptação às mudanças de
  18. 18. configuração de hardware. Desta forma, o usuário não precisa entender asparticularidades do hardware para instalar ou remover dispositivos.O suporte a Plug-and-Play requer uma cooperação entre o hardware, osdrivers de dispositivo e os diferentes níveis do sistema operacional. Algumascapacidades do suporte a esse sistema são:• O gerenciador PnP reconhece automaticamente dispositivos instalados,um processo que inclui enumerar dispositivos acoplados ao sistemadurante uma operação de boot e detectar a adição ou remoção dedispositivos enquanto o sistema encontra-se em execução.• A alocação de recursos de hardware é um papel que o gerenciador dePnP desempenha juntando as exigências dos recursos dos dispositivosconectados ao sistema e, em um processo chamado arbitragem derecursos, designar recursos para que os dispositivos conheçam asexigências necessárias para suas operações. Esse processo tambémdeve ser feito de forma dinâmica pelo gerenciador de PnP.• O gerenciador de PnP também é responsável por carregar os driversapropriados.• O gerenciador de PnP implementa aplicações e mecanismos de driverpara detecção das mudanças nas configurações de hardware.Aplicações ou drivers às vezes requerem um dispositivo de hardwareespecífico para a função, então o Windows NT oferece os meios paraque sejam conhecidos notificações da presença, adição ou remoção dedispositivos.2.2.4 Gerenciador de CacheGeralmente, a cache é dividida em blocos de 256 KB. Cada bloco de cache édescrito por um VACB (Virtual-Address Control Block) que armazena osendereços virtuais e também um offset de arquivo para a região mapeada em
  19. 19. memória, juntamente com o número de processos que estão usando a regiãoespecificada. O VACB reside em um vetor que é mantido pelo gerenciador decache.Para cada arquivo aberto, o gerenciador de cache mantém um índice separadono vetor VACB. Esse vetor possui um elemento para cada pedaço de 256 KB doarquivo. Dessa forma, um arquivo de 2 MB teria 8 entradas no vetor de índicesVACB. Uma entrada nesse vetor de índices aponta para o VACB se aquela partedo arquivo encontra-se na cache. Em caso contrário, ela tem um valor nulo.2.3 Estruturas de Dados de E/SQuatro estruturas de dados estão associadas com as requisições de E/S:objetos de arquivo, objetos de driver, objetos de dispositivo e pacotes derequisição de E/S ( I/O Request Packets - IRP ). Cada uma dessas estruturas édefinida em um cabeçalho de arquivo DDK denominado Ntddk.h.2.3.1 Objetos de ArquivoObjetos de arquivo são construções em modo kernel para lidar com arquivosou dispositivos. Eles estabelecem critérios para os objetos no Windows NT: elessão recursos de sistema em que dois ou mais processos em modo-usuário podemcompartilhar, eles podem ter nomes, são protegidos por um tipo de segurançabaseada em objeto e suportam sincronização. Recursos compartilhados nosistema de E/S são manipulados como se fossem objetos.Objetos de arquivo provêem uma representação baseada em memória dosrecursos que obedecem a uma interface centrada em E/S, a qual eles podem serlidos de ou escritos para.A seguir, serão descritos alguns atributos dos objetos de arquivo:
  20. 20. • Nome de arquivo (Filename): identifica o arquivo físico a que o objeto dearquivo se refere.• Byte corrente de offset (Current byte offset): identifica a localização atualno arquivo (válido apenas para operações de E/S sincronizadas).• Modos de compartilhamento(Share modoes): indica onde outroschamadores podem abrir os arquivos para ler, escrever ou deletaroperações enquanto o chamador atual está em funcionamento.• Ponteiro para objeto de dispositivo (Pointer to device object): indica otipo de dispositivo onde o arquivo reside.• Ponteiro para o bloco de parâmetro de volume (Pointer to the volumeparameter block - VPB): indica o volume ou a partição em que o arquivoreside.Quando um chamador abre um arquivo para um dispositivo simples, ogerenciador de E/S retorna um handle para um objeto de arquivo. A figura abaixoilustra o que acontece quando um arquivo é aberto.
  21. 21. Figura 3: Abrindo um objeto de arquivoNesse exemplo, (1) um programa em C chama uma rotina chamada fopen, aqual (2) chama uma função da API Win32 chamada CreateFile. A DLL dosubsistema Win32 chamada kernel32.dll então (3) chama uma função nativadenominada NtCreateFile que se encontra no arquivo Ntdll.dll. A rotina presentenesse arquivo contém a instrução apropriada para causar uma transição do modokernel para o sistema de despachador de serviço (system service dispatcher), oqual (4) chama a rotina real NtCreateFile no arquivo Ntoskrnl.exe.Assim como outros objetos do executivo, arquivos de objeto são protegidos porum descritor de segurança que contém uma lista de controle de acesso (acess-control list – ACL).
  22. 22. 2.3.2 Objetos de Driver e Objetos de DispositivoQuando uma thread abre um handle para um objeto de arquivo, o gerenciadorde E/S deve determinar qual driver ou drivers do objeto de arquivo deve serchamado para processar a requisição. O gerenciador de E/S deve ser capaz delocalizar essa informação da próxima vez que uma thread usar o mesmo handlede arquivo.Um objeto de driver representa um driver individual no sistema. O gerenciadorde E/S obtém o endereço de cada rotina de envio dos drivers do objeto de driver.Já os objetos de dispositivo representam um dispositivo lógico ou físico no sistemae descrevem suas características. O gerenciador de E/S cria um objeto de driverenquanto um driver é carregado no sistema, e então chama uma rotina deinicialização do driver denominada DriverEntry, a qual encaixa os atributos doobjeto com os pontos de entrada do driver. Após ser carregado, um driver podecriar objetos de dispositivo para representar dispositivos, ou até mesmo umainterface para o driver, através de uma chamada a rotina IoCreateDevice.2.3.3 Pacotes de Requisição de E/SO pacote de requisição de E/S (I/O Request Packet - IRP) é onde o sistema deE/S armazena informações necessárias para processar uma requisição de E/S.Quando uma thread chama um serviço de E/S, o gerenciador de E/S constrói umIRP para representar a operação enquanto ele atravessa o sistema de E/S.Um IRP consiste de duas partes: um cabeçalho fixo, e um ou mais pilhas delocalização. A parte fixa contém informações acerca do tipo e tamanho darequisição, se a requisição é síncrona ou assíncrona, um ponteiro para um buffer einformações a respeito do estado de operação da requisição.
  23. 23. 2.4 Processamento de E/SAs requisições de E/S passam por diversos estágios de processamento. Osestágios variam dependendo se a requisição se destina a um dispositivo operadopor um driver de camada única ou por um driver de múltiplas camadas, e tambémem relação a operações síncronas ou assíncronas.2.4.1 Tipos de E/SAs aplicações possuem diversas opções para as requisições de E/S que elasgeram. Elas podem especificar E/S síncrona ou assíncrona, E/S que mapeia umdado de dispositivo em um espaço de endereço da aplicação.Muitas operações de E/S das aplicações são síncronas, ou seja, a aplicaçãoespera enquanto o dispositivo realiza a transferência de dados e retorna umcódigo de estado quando a operação de E/S termina. O programa pode continuare acessar os dados transferidos imediatamente. Quando usados em sua formamais simples, as rotinas da API Win32 ReadFile e WriteFile são executadas deforma síncrona. Elas completam uma operação de E/S antes de retornar ocontrole ao chamador.Operações de E/S assíncronas permitem que uma aplicação faça umarequisição de E/S e continue executando enquanto o dispositivo transfere osdados. Esse tipo de E/S pode melhorar o tempo de resposta de uma aplicação porpermitir que a mesma continue a realizar outro tipo de trabalho enquanto esperapelo término de uma operação de E/S. Para usar uma operação assíncrona deE/S, deve-se especificar um flag denominado FILE_FLAG_OVERLAPPED quandofor chamado a função CreateFile da API Win32. Após emitir a operaçãoassíncrona de E/S, a thread deve ter cuidado para não acessar nenhum dado daoperação de E/S até o driver de dispositivo terminar a transferência de dados. Athread deve sincronizar sua execução com o término da requisição de E/Smonitorando um handle de um objeto de sincronização.
  24. 24. Internamente, as operações de E/S são representadas por IRP’s que sãorealizados de forma assíncrona, ou seja, uma vez iniciada a requisição de E/S, odriver de dispositivo retorna ao sistema de E/S. O fato de o sistema de E/Sretornar imediatamente ao chamador depende se o arquivo foi aberto de formasíncrona ou assíncrona.Por outro lado, a E/S rápida é um mecanismo especial que permite que osistema de E/S vá diretamente ao driver de sistema de arquivo ou ao gerenciadorde cache para completar uma requisição de E/S.A E/S mapeada em arquivo é um importante esquema do sistema de E/S, oqual é produzido pelo sistema de E/S e pelo gerenciador de memória. A E/Smapeada em arquivo refere-se a habilidade de visualizar um arquivo residente emdisco como parte de um processo da memória virtual. Um programa pode acessaro arquivo como um vetor sem bufferizar os dados ou realizar E/S em disco. A E/Smapeada em arquivo está disponível em modo usuário através das funções dosubsistema Win32 CreateFileMapping e MapViewOfFile e é rotineiramente usadapara operações importantes como caching um arquivo e ativação de imagem(carregar e rodar programas executáveis). O gerenciador de cache é umconsumidor importante desse esquema.Uma operação de requisição de E/S síncrona para um driver de dispositivocom camada única em modo kernel é descrito a seguir. Tal operação consiste desete passos:1. A requisição de E/S passa pelo subsistema DLL.2. O subsistema DLL chama o serviço do gerenciador de E/S denominadoNtWriteFile.3. O gerenciador de E/S aloca um IRP descrevendo a requisição e o enviapara o driver de dispositivo através de uma chamada para a funçãoIoCallDriver.4. O driver transfere os dados do IRP para o dispositivo e inicia a operaçãode E/S.5. O driver sinaliza o término da E/S através de uma interrupção da CPU.
  25. 25. 6. Quando o dispositivo completa a operação e interrompe a CPU, o driverde dispositivo dá assistência à interrupção.7. O driver chama uma função do gerenciador de E/S chamadoIoCompleteRequest, que informa o término do processamento darequisição de IRP, e o gerenciador de E/S completa a requisição de E/S.Esses sete passos são descritos na figura a seguir.Figura 4: Enfileirando e completando uma requisição de E/SApós um dispositivo de E/S completar uma transferência de dados, ocorre umainterrupção e o kernel do Windows NT, o gerenciador de E/S e o driver dedispositivo são chamados. Quando uma interrupção de dispositivo ocorre, oprocessador transfere o controle para o “trap handler” do kernel, o qual indexa na
  26. 26. tabela de despache de interrupção a localização de uma rotina para tratamento deinterrupção (ISR) para o dispositivo em questão.2.5 Suporte a RAIDO Windows NT oferece também suporte a RAID, tanto por hardware como porsoftware. No suporte a RAID por hardware são oferecidos drivers de disco comcapacidade de gerenciar controladoras RAID. Desta forma, diferentes discospodem trabalhar em conjunto para compor um ou mais discos lógicos. No RAIDpor hardware, a própria controladora gerencia a criação e a manutenção dainformação de redundância necessária à recuperação dos dados [OLIVEIRA,2004].O suporte a RAID por software é disponível apenas nas versões server doWindows NT. Ele emula a partir de serviços do sistema operacional ofuncionamento de uma controladora com suporte RAID. Um driver de dispositivodenominado FTDISK é responsável por essa tarefa. Esse driver oferece RAID 1 eRAID 5.2.6 Plug-and-playOutro detalhe importante a respeito do NT são as melhorias introduzidas nafuncionalidade plug-and-play, ou seja, a capacidade de um sistema de reconhecere adaptar-se dinamicamente a alterações ou modificações em sua forma ouconfiguração inicial de hardware. Tal melhora traduz-se em um modelo genéricopara implementação e gerência de drivers de dispositivo denominado WDM(Win32 Driver Model). Este modelo permite fácil portabilidade de drivers dedispositivos de um sistema operacional para outro. Os drivers de dispositivo queseguem o WDM permitem compatibilidade a nível de código binário entre todas as
  27. 27. plataformas baseadas em processadores x86 executando Windows NT e Windows98, e são portáveis a nível do código fonte para qualquer outra arquitetura.2.7 Suporte a multiprocessamentoO Windows NT oferece suporte a multiprocessamento. Um ambientemultiprocessado é aquele em que o mesmo código pode rodar simultaneamenteem mais de um processador. Embora todo o sistema operacional precise estarenvolvido com tal característica, é no sistema de E/S que o multiprocessamentofica mais evidente, mais especificamente nos drivers de dispositivo.Um driver pode ser executado em dois ou mais processadoressimultaneamente, necessitando de uma sincronização aos dados do mesmo.Técnicas de exclusão mútua para proteção a recursos compartilhados devem serutilizadas, já que, em um ambiente multiprocessado, podem ocorrer erros porinconsistência de dados.2.8 Recuperação de falha de energiaCada driver de dispositivo tem de saber quando efetivamente ocorreu umafalha de energia, reajustando posteriormente o dispositivo por ele operado.Qualquer operação de E/S que tenha sido interrompida deve ser reinicializada,mas se isso não for possível, pelo menos o gerenciador de E/S deve ser notificadoda falha em uma operação de E/S a fim de retornar uma condição de erro.O gerenciador de E/S, juntamente com o kernel, oferece um recurso quepermite aos drivers de dispositivo lidar de forma razoavelmente tranqüila cominterrupções no fornecimento de energia elétrica. Quando a energia acaba, ocorreuma interrupção de falha de energia e o sistema operacional tem um breveperíodo de tempo para preparar-se para o blecaute. O kernel copia rapidamente
  28. 28. para a memória todos os registros importantes do sistema, incluindo o contador deprograma. Se a memória do computador estiver equipada com uma bateriareserva, estas informações são gravadas e, quando a energia voltar, o kernel e osistema de E/S podem usá-las para reiniciar ou encerrar as operações de E/S queforam interrompidas. O sistema de E/S pode reiniciar ou encerrar as operações deE/S que foram interrompidas.No Windows NT, cada driver de dispositivo pode executar várias tarefas paraajudar na recuperação de falha de energia elétrica. Primeiro, cada driver dedispositivo pode criar e registrar uma rotina de recuperação de energia quereajusta o dispositivo para um estado conhecido após o blecaute. Depois derestaurado o fornecimento, o kernel localiza e executa a rotina de cada driver.Segundo, cada driver assegura que não será possível ocorrer uma interrupçãode falha de energia enquanto o driver estiver gravando seqüências de dadoscríticos em seu dispositivo. Isto é importante porque, quando o fornecimentoelétrico for restaurado, o processador dará continuidade a sua execução nocontador de programa em que foi interrompido.
  29. 29. 3. GERENCIAMENTO DE MEMÓRIAA arquitetura de memória do Windows NT é um sistema de memória virtualpaginada por demanda. É baseada em um espaço de endereçamento contínuo elinear de 32 bits, que permite a cada processo do Windows NT acessar até 4 GBde memória. O Windows NT mapeia os endereços da memória virtual para amemória física em blocos de 4 KB, denominados páginas. Utilizando a memóriavirtual do Windows NT, parte do código e algumas informações dos aplicativos sãomantidas na RAM, enquanto outras informações podem ser paginadastemporariamente na memória virtual. Quando as informações paginadas sãorequisitadas, o Windows NT as carrega de volta para a RAM, paginando outrasinformações para a memória virtual, se necessário. Este modelo de memóriapermite que os usuários executem aplicativos que utilizam mais memória do que aque o hardware suporta.Neste trabalho, apresentaremos como funciona o Gerenciamento deMemória no Windows NT, como o Windows NT implementa a memória virtual ecomo ele gerencia o subconjunto mantido na memória física. Estas atividadesenvolvem duas tarefas principais:• Traduzir ou mapear o espaço de endereços virtuais de um processo para amemória física.• Paginar parte do conteúdo da memória para o disco quando ela se tornarinsuficiente e trazer o conteúdo de volta para a memória física quando for
  30. 30. necessário.Além de fornecer o gerenciamento de memória virtual de 32 bits, ogerenciador de memória fornece um conjunto básico de serviços em que os váriossubsistemas de ambiente do Windows NT são montados. Esses serviços incluemarquivos mapeados na memória (internamente chamados section object), memóriade copy-on-write e suporte para aplicações usando espaços de endereçosgrandes e esparsos. Neste trabalho, mostraremos esses serviços básicos eexplicaremos os conceitos pertinentes, como memória reservada versuscomprometida, memória compartilhada e também a estrutura interna e oselementos que compõem o gerenciador de memória.3.1 Memória VirtualA memória virtual do Windows NT foi implementada por Lou Perazzoli. Louestabeleceu as seguintes metas para o gerenciador de memória virtual:• Torná-lo o mais portátil possível.• Ser confiável e eficiente em aplicações de todos os tamanhos, sem exigiradaptações do sistema por um usuário ou administrador.• Proporcionar recursos modernos de gerenciamento de memória, comoarquivos mapeados, memória do tipo copy-on-write e suporte a aplicaçõesque usam espaços de endereçamento grandes e possivelmente escassos.• Permitir aos processos alocar e gerenciar a memória privativa.
  31. 31. • Proporcionar mecanismos que suportam os subsistemas de ambiente,como permitir a um subsistema (com os direitos apropriados de acesso)gerenciar a memória virtual de um processo cliente.• Equilibrar as necessidades de multiprocessamento com velocidade deacesso à memória. (Por exemplo, proteger as estruturas de dados usandovários níveis de bloqueio pode aumentar o paralelismo no gerenciador dememória virtual, mas cada bloqueio pode criar improdutividade adicional).O espaço de endereçamento virtual é o conjunto de endereços de memóriadisponíveis para uso pelas threads de um processo. Todo processo tem umespaço de endereçamento virtual exclusivo que normalmente é muito maior doque a memória física.Apesar de o número de endereços físicos de um determinado computadorser limitado pela quantidade de memória que o mesmo possui, o número deendereços de memória virtual só é limitado pelo número de bits de um endereçovirtual.A discrepância entre um espaço de endereçamento físico e um espaço deendereçamento virtual torna inevitável as duas tarefas de um sistema de memóriavirtual:• Traduzir, ou mapear um subconjunto dos endereços virtuais de cadaprocesso para localizações de memória física. Quando uma thread lê ouescreve em seu espaço de endereçamento virtual, o sistema de memóriavirtual usa o endereço virtual para encontrar o endereço físico correto antes
  32. 32. de transferir os dados.• Gravar parte do conteúdo de memória para o disco quando as threads dosistema tentam usar mais memória do que há fisicamente disponível.A movimentação de dados da memória para o disco (e vice-versa) seriaabsurdamente lenta se o gerenciador de memória virtual movesse um byte decada vez. É por isto que o espaço de endereçamento virtual é dividido em blocosde tamanho igual, chamados páginas. Já a memória física é dividida em blocoschamados de estruturas de página, que são usados para conter páginas. Cadaprocesso tem um conjunto de páginas de seu espaço de endereçamento virtualpresente na memória física em um dado momento. As páginas que estão namemória física e estão disponíveis são chamadas de páginas válidas. As páginasque estão armazenadas em disco (ou que estão na memória, mas nãodisponíveis) são chamadas de páginas inválidas, conforme ilustra a Figura 5.
  33. 33. Figura 5: Mapeando Páginas Virtuais para estruturas de página físicasQuando uma thread em execução acessa um endereço virtual em umapágina marcada como inválida, o processador emite uma trap de sistemachamada de falta de página. O sistema de memória virtual localiza a páginasolicitada no disco e carrega-a para uma estrutura de página livre na memóriafísica. Quando o número de estruturas de página disponíveis fica baixo, o sistemade memória virtual seleciona estruturas de página para serem liberadas e copiaseu conteúdo para o disco. Esta atividade, conhecida como paginação, éimperceptível ao programador.Apesar do mapeamento de endereços virtuais para endereços físicos e a
  34. 34. transferência de dados de (ou para o) armazenamento swap serem as principaistarefas de um sistema de memória virtual, ele precisa cumprir outras obrigaçõestambém:• Permitir que dois processadores compartilhem a memória com facilidade eeficiência.• Proteger tanto a memória compartilhada quanto a memória privativa contraacesso desautorizado.• Se for executado em computadores multiprocessados, precisa responder afaltas de página de mais de uma thread de cada vez.3.2 Gerenciando a MemóriaO gerenciador de Memória Virtual fornece um conjunto de serviços nativosque um processo pode usar para gerenciar diretamente sua memória virtual. Estesserviços permitem que um processo faça o seguinte:• Aloque memória em um processo de dois estágios.• Leia e escreva na memória virtual.• Bloqueie páginas virtuais na memória física.• Obtenha informações sobre páginas virtuais.• Proteja páginas virtuais.• Execute a operação de swapping.
  35. 35. 3.2.1 Estados de uma página virtualCada página virtual pode estar em um destes três estados: livre, reservado,ou commited.O gerenciador de memória virtual estabelece uma abordagem de duasfases para alocar memória: reservado e commited, através da função VirtualAlloc.Essas duas fases podem ser chamadas na mesma chamada de função através dafunção VirtualAllocEx.Uma página livre não está em uso atual e uma referência para ela causaráuma falta.Quando um processo inicia, todas suas páginas estão no estado de livre atéo programa e seus dados iniciais serem mapeados para o espaço deendereçamento. Uma vez que dados ou códigos são mapeados numa página,está página é dita como commited. Uma referência para uma página commited émapeada usando o hardware de memória virtual, e é considerado um sucesso sea página está na memória principal. Se a página não estiver na memória principal,uma falta de página ocorre e o sistema operacional faz uma busca no disco paraencontrar essa página e traze-la para a memória principal.Uma página virtual pode também estar no estado de reservada, significandoque ela não está disponível para ser mapeada até a reserva ser removidaexplicitamente. Uma referência a uma página reservada causará uma falta, poisela não está mapeada. Pode-se ver a vantagem de possuir página reservadaquando, por exemplo, uma nova thread é criada, 1 MB de espaço de pilha é
  36. 36. reservada no espaço de endereçamento virtual do processo, mas apenas umapágina é alocada. Essa técnica significa que a pilha pode crescer eventualmenteaté 1 MB sem o receio de que alguma outra thread aloque o pedaço de espaço deendereçamento virtual contíguo necessário.Em adição aos atributos livre, reservado e alocado, as páginas possuemoutros atributos, tais como passível de leitura, passível de escrita e executável.Por questão de desempenho, o Windows NT permite que um processo, comprivilégios necessários, possa bloquear páginas em memória, fazendo com queessas páginas nunca sofram procedimento swapping.Finalmente, quando é reservada uma região do espaço de endereços, oWindows NT assegura que o tamanho da região seja um múltiplo do tamanho dapágina do sistema, qualquer que seja. Por exemplo, como os sistemas x86 usampáginas de 4 KB, se se tentasse reservar uma região da memória com 18 KB, aquantidade real reservada em um sistema x86 seria 20 KB.3.2.2 Memória CompartilhadaAssim como todos os outros componentes do Windows NT, o gerenciadorde memória virtual é totalmente paralelo. Ele roda simultaneamente em todos osprocessadores de um computador multiprocessado e tem de compartilhar suasestruturas de dados com as threads que estão sendo executadas emprocessadores diferentes. Portanto, era importante criar uma solução segura eeficiente para o compartilhamento de memória no Windows NT.
  37. 37. Memória compartilhada pode ser definida como a memória que é visível apartir de mais de um processo ou que está presente em mais de um espaço deendereçamento virtual. A abordagem do Windows NT ao compartilhamento derecursos é implementá-los como objetos protegidos e a memória não é nenhumaexceção. Dois processos podem compartilhar um mesmo espaço deendereçamento de memória, ver Figura 6. O Windows NT chama um bloco dememória compartilhada de section object, e oferece uma abstração de visão paraos processos. Essa abstração consiste em um processo de mapear uma porçãode seu espaço de endereçamento a um objeto, o qual é utilizado por outrosprocessos para acessos compartilhados a essa porção. O mecanismo deabstração de visão também permite que em caso de swapping de uma regiãocompartilhada de memória, as páginas correspondentes a essa região sejamtransferidas ou para a área de swap ou para um arquivo especial chamadomapped file. Também é possível fixar um endereço virtual para essa região,permitindo que ela resida sempre em um mesmo endereço virtual em todos osprocessos que a utilizam.
  38. 38. Figura 6: Mapeando Visões em uma SeçãoO executivo do NT usa os arquivos mapeados para carregar imagensexecutáveis para a memória e o gerenciador de cache do sistema usa os arquivosmapeados para ler e gravar em páginas da cache. O sistema de E/S do NT usa os
  39. 39. arquivos mapeados para executar solicitações de entrada e saída, permitindo aogerenciador de memória virtual paginar para o disco qualquer mudança ocorrida,como parte de suas operações normais de paginação.3.2.2.1 Section ObjectOs objetos de seção, assim como outros objetos, são alocados edesalocados pelo gerenciador de objetos. Este cria e inicializa um cabeçalho deobjeto, o qual é utilizado para gerenciar os objetos; o gerenciador de memóriavirtual define o corpo do section object. O gerenciador de memória virtual tambémimplementa serviços que as threads do modo usuário podem chamar pararecuperar e alterar os atributos armazenados no corpo dos section object. Osection object pode ser visto na Figura 7.Figura 7: Section Object
  40. 40. Mapear a visão de um section object torna visível uma parte da seção noespaço de endereçamento virtual de um processo. Igualmente, desmapear a visãode um section object remove-a do espaço de endereçamento virtual do processo.O compartilhamento ocorre quando dois processos mapeiam partes domesmo objeto de seção em seus espaços de endereçamento. Quando doisprocessos compartilham memória desta maneira, eles precisam sincronizar seusacessos a ela para evitar a alteração de dados ao mesmo tempo. Eventos,semáforos ou mesmo bloqueios dependentes do hardware podem ser usadospara sincronizar o acesso a uma seção compartilhada. Os section objectspropriamente ditos não são definidos como objetos de sincronização; ou seja, umathread não pode sincronizar sua execução aguardando um handle para umsection object. As aplicações do Win32 podem usar mutexes, eventos, seçõescríticas ou semáforos para sincronizar seu acesso ao objeto de mapeamento dearquivo - equivalente a um section object.Para mapear a visão de uma seção, o processo precisa primeiro adquirirum handle para ela. O processo que cria o section object sempre tem um handle.Outros processos (aqueles com direito de acesso apropriado) podem abrirhandles para o section object se a seção tiver nome. Alternativamente, o processopode receber um handle para um section object através de herança ou quando umoutro processo duplica seu handle de seção e passa o handle duplicado para oprocesso receptor. O compartilhamento de memória ocorre em todos estes casos.Se uma seção compartilhada é criada como objeto temporário, o gerenciador de
  41. 41. objetos elimina a memória compartilhada quando a última referência ao sectionobject é emitida.3.2.3 Proteção de MemóriaO Windows NT oferece proteção de memória para os processos e para osistema operacional.O objetivo dessa proteção é que nenhum processo do usuário possainadvertidamente corromper o espaço de endereço de outro processo (ou dopróprio sistema operacional). Essa proteção é fornecida de quatro formas:• Todas as estruturas de dados e memory pools em nível de sistema usadospelos componentes do modo kernel do sistema só podem ser acessadosestando no modo kernel. Se houver uma tentativa de violação dessacondição, o hardware gerará uma falta, que por sua vez o gerenciador dememória informa a thread como uma violação de acesso.• Cada processo possui um espaço de endereçamento separado e privado,protegido contra acesso por qualquer thread que pertença a outro processo(exceto quando a memória compartilhada está sendo usada, nesse caso,apenas as páginas compartilhadas podem ser vistas por mais de umprocesso).• Todos os processadores aceitos pelo Windows NT oferecem alguma formade proteção de memória controlada pelo hardware (como leitura/escrita,
  42. 42. apenas leitura e assim por diante).• Os section object da memória compartilhada possuem listas de controle deacesso (ALCs) padrão do Windows NT, que são verificadas quando osprocessos tentam abri-los, limitando assim o acesso da memóriacompartilhada aos processos com os devidos direitos.Essa ultima forma é chamada de cópia-na-escrita (Copy-on-Write). Aproteção de página por cópia-na-escrita é uma otimização que o gerenciador dememória usa para economizar a memória física. Quando um processo mapeiauma visão de cópia-na-escrita de um section object que contém páginas deleitura/escrita, em vez de criar um processo de cópia privada quando a visão formapeada, o gerenciador de memória adia a criação de uma cópia das páginas atéque a página seja modificada. Por exemplo, como vemos na Figura 8, doisprocessos estão compartilhando três páginas, cada uma marcada como cópia-na-escrita.Figura 8: Antes do copy-on-write
  43. 43. Se um thread em qualquer processo escreve na página, uma falta degerenciamento de memória é gerada. O gerenciador de memória vê que a escritaé para uma página de cópia-na-escrita e, em vez de informar a falta como umaviolação de acesso, ele reserva uma nova página de leitura/escrita na memóriafísica (copiando a página no arquivo de paginação), copia o conteúdo da páginaoriginal para a nova página, atualiza a informação de mapeamento de páginacorrespondente nesse processo apenas para apontar para o novo local e dispensaa exceção, fazendo assim com que a instrução que gerou a falta seja novamenteexecutada. Dessa vez, a operação de escrita tem sucesso, mas, como vemos naFigura 9 a seguir, a página recém copiada agora é privada ao processo que fez aescrita, e não é visível aos outros processos que ainda compartilham a página decópia-na-escrita. Cada novo processo que escreve nessa mesma páginacompartilhada também receberá sua própria cópia privada.Figura 9: Depois do copy-on-write
  44. 44. A cópia-na-escrita é usada para implementar o suporte para ponto deinterrupção (breakpoint) nos depuradores.A proteção de página cópia-na-escrita é um exemplo de uma técnica deotimização chamada Avaliação Preguiçosa (lazy evaluation), que o gerenciador dememória virtual utiliza sempre que possível. Os algoritmos de avaliaçãopreguiçosa evitam efetuar uma operação dispendiosa até que ela sejaabsolutamente necessária. Se a operação nunca foi solicitada, então não se perdetempo com ela.3.3 ImplementaçãoA maioria dos sistemas operacionais de 32 bits utilizam um espaço deendereçamento virtual de até 4 GB de memória virtual, separando metade dessamemória virtual para o sistema operacional e a outra metade para dados e códigosdos usuários. O Windows NT também utiliza esse método e podemos observaressa distribuição na Figura 10. O NT também oferece uma opção para modificar aalocação de memória para um processo, de forma que esse possa ter 3 GB parausuário e apenas 1 GB ao sistema operacional. Essa modificação é muito útil paraalgumas aplicações, tais como banco de dados, que passaram a poder armazenaruma parcela maior de dados dentro do espaço endereçado da própria aplicação.O Windows NT ainda prevê uma extensão denominada VLM(Very Large Memory),
  45. 45. para arquiteturas de 64 bits, que permite um processo usuário alocar até 28 GB dememória virtual suplementar.Figura 10: Espaço de Endereçamento VirtualOs primeiros e os últimos 64KB do espaço de endereçamento virtual decada processo normalmente não são mapeados. Esta escolha foi feitaintencionalmente para ajudar na captura de erros dos programas. Ponteirosinválidos freqüentemente possuem os valores 0 ou -1 e tentativas de usá-los noWindows NT causariam uma parada imediata, ou pior, escreveriam em um localincorreto da memória. Em contra partida, quando está sendo rodado em modo deemulação programas do antigo MS-DOS, esses 64 + 64 KB podem ser mapeados.
  46. 46. A partir do kilobyte 64, temos os códigos e dados privados do usuário, istoextende-se até quase 2 GB. Os últimos pedaços dos primeiros 2 GB contémalguns contadores do sistema e temporizadores que são compartilhados paratodos os usuários dando-lhes permissão de leitura, somente. Isso permite aosprocessos acessá-los sem um overhead de chamada de sistema. Os outros 2 GBsão compartilhados entre todos os processos, exceto a tabela de páginas, o qualcada processo utiliza a sua. Esses 2 GB não são passiveis de escrita e tambémnão podem ser lidos por processos de modo usuário.3.3.1 Mecanismos de PaginaçãoTodo processador que suporta a memória virtual o faz de maneira diferente.Conseqüentemente, o código que tem interface direta com o hardware dememória virtual não é portátil e tem de ser modificado para cada plataforma.Os endereços virtuais freqüentemente usados provavelmente têm inserçõesna TLB (Translation Look-aside Buffer), que propicia traduções extremamenterápidas de endereço físico para virtual. Se um endereço virtual não está presentena TLB, ele poderá estar na memória, mas o software de memória virtual terá deencontrá-lo, caso em que o tempo de acesso é ligeiramente mais lento. Se umapágina virtual foi paginada fora da memória, o sistema de memória virtual invalidasua entrada na TLB. Se um processo a acessa novamente, ocorre uma falta depágina e o gerenciador de memória virtual traz a página novamente para amemória e recria uma entrada para ele na TLB.
  47. 47. O kernel e o gerenciador de memória virtual usam tabelas de páginascriadas por software para encontrar páginas que não estão presentes na TLB. Astabelas de páginas estão disponíveis na maioria dos sistemas de memória virtual:às vezes, elas são implementadas pelo hardware, e às vezes, pelo software. Emtermos conceituais, a tabela de páginas assemelha-se à estrutura de dadosmostrada na Figura 11.Figura 11: Tabela de Páginas ConceitualUma entrada na tabela de páginas (PTE - page table entry) contém todasas informações necessárias para o sistema de memória virtual localizar uma
  48. 48. página quando uma thread usa um endereço. Em um sistema de memória virtualsimples, uma entrada inválida em uma tabela de páginas significa que a páginanão está na memória física e tem de ser carregada do disco. Ocorre uma exceçãode falta de página e o software de paginação carrega a página solicitada para amemória e atualiza a tabela. O processador reemite a instrução que gerou a faltade página. Desta vez, porém, a inserção da tabela de páginas é válida e os dadossão recuperados da memória com sucesso.No momento de localizar uma entrada na tabela de páginas, o gerenciadorde memória virtual (e o kernel do NT) traduz o endereço virtual do formato MIPSpara o endereço no formato Intel, usando partes diferentes dele comodeslocamentos na estrutura da tabela de páginas. Além disso, uma inserção naTLB sempre contém o endereço virtual base do diretório de página do processoatualmente em execução (É este o motivo pelo qual um processo usuário nãopode “ver” o espaço de endereçamento do outro. Eles têm diretórios de páginadiferentes, que apontam para tabelas de páginas diferentes).As entradas da tabela de páginas nestas tabelas definidas pelo NTrepresentam um aperfeiçoamento sobre a tabela conceitual mostradaanteriormente. Cada entrada da tabela de páginas (e cada entrada do diretório depágina) tem um sinalizador de transição. Se a entrada da tabela de páginas estámarcada como inválida e o sinalizador de transmissão está ativado, a página éescolhida para ser reutilizada, mas seu conteúdo ainda é válido. Validar umapágina transicional é uma operação muito rápida porque o gerenciador de
  49. 49. memória virtual não precisa ler a página do disco para a memória. As entradas databela de páginas também contêm sinalizadores que registram as proteções anível de página que o gerenciador de memória virtual aplica a cada página.Quando uma estrutura de página é compartilhada por dois processos, ogerenciador de memória virtual insere um artifício nas suas tabelas de páginas. Aestrutura de dados que ele insere é chamada de protótipo de entrada na tabela depáginas (protótipo PTE).O protótipo PTE, uma estrutura de 32 bits que parece com uma entrada detabela de páginas normal, permite ao gerenciador de memória virtual gerenciar aspáginas compartilhadas sem precisar atualizar as tabelas de páginas de cadaprocesso que compartilha a página. Por exemplo, uma página de código ou dedados compartilhada pode ser paginada para o disco em um determinadomomento. Quando o gerenciador de memória virtual recupera a página do disco,ele só precisa atualizar o ponteiro armazenado no prótipo PTE para a novalocalização física, e as tabelas de páginas permanecem as mesmas. Os protótiposde PTE são alocados no espaço paginado do sistema, portanto, como as entradasna tabela de páginas, podem sofrer swapout, se necessário.3.3.2 Políticas de PaginaçãoOs sistemas de memória virtual geralmente definem três políticas que ditamcomo (ou quando) a paginação é efetuada: uma política de busca, uma política decolocação e uma política de substituição.
  50. 50. A política de busca determina quando o paginador deve trazer a página dodisco para a memória. Um tipo de política de busca tenta carregar as páginas queum processo irá precisar antes que ele as solicite. Outras políticas de busca,chamadas de políticas de paginação por demanda, carregam uma página para amemória física apenas quando ocorre uma falta de página. Em um sistema depaginação por demanda, o processo incorre em muitas faltas de página quandosuas threads são executadas pela primeira vez, porque elas fazem referência aoconjunto inicial de páginas que lhes são necessárias. Depois que este conjunto depáginas é carregado para a memória, a atividade de paginação do processodiminui.Quando uma thread recebe uma falta de página, o sistema de gerencia-mento de memória também tem de determinar onde colocar a página virtual namemória física. O conjunto de regras que ele usa chama-se política de colocação.As políticas de colocação, embora normalmente complicadas para arquiteturas dememória segmentada, em geral são simples para arquiteturas lineares, querequerem que apenas uma estrutura de página livre seja encontrada. No NT, se amemória não está esgotada, o gerenciador de memória virtual simplesmenteseleciona a primeira estrutura de página em uma lista de estruturas de páginalivres. Se a lista está vazia, ele cruza uma série de outras listas por ele mantidas;a ordem dependerá do tipo de falta de página ocorrido.Se a memória física estiver repleta quando ocorrer uma falta de página,uma política de substituição é usada para determinar que página virtual deve ser
  51. 51. removida da memória para liberar espaço para a página nova. As políticas desubstituição de página no Windows NT variam de acordo com a arquitetura ouprocessador. Para arquiteturas do tipo multiprocessador baseadas emprocessadores da família Intel, e em todas as máquinas baseadas emprocessadores da família Alpha, a estratégia utilizada é essencialmente FIFO(First In, First Out) local. Nessa estratégia, considera-se para fins de seleção dapágina a ser substituída em memória, apenas as páginas pertencentes aoprocesso. Nas arquiteturas de monoprocessadores Intel, o algoritmo de seleçãode página a ser substituída é LRU (least recently used). Implementado através doalgoritmo do relógio, o algoritmo LRU exige que o sistema de memória virtualregistre quando uma página de memória é usada. Quando uma nova estrutura depágina é solicitada, a página que não foi usada há mais tempo é paginada para odisco e sua estrutura é liberada para satisfazer a falta de página.3.3.3 Gerenciamento da memória físicaO número de páginas que um processo ocupa na memória é armazenadoatravés do mecanismo de working set. Para cada processo, é definido um valormínimo e um valor máximo para o tamanho desse working set, a partir do tamanhoda memória física. Quando há uma elevada ocorrência de falta de página, ogerenciador da memória inicia uma verificação do working set de todos osprocessos residentes na memória. Os processos que tiverem mais páginas namemória que o valor mínimo terão seus working sets reduzidos, e suas áreas de
  52. 52. memórias liberadas serão disponibilizadas para serem alocadas por outrosprocessos.O gerenciador da memória física armazena a movimentação das páginasna memória através de listas. Cada página contida na memória está presente dentro do working set de algumprocesso ou em algumas dessas listas. Essas listas são apresentadas a seguir:• Listas de páginas disponíveis (limpas): contêm as páginas que foramrecentemente removidas do working set de algum processo, mas aindaestão associadas a ele. Essas páginas possuem uma cópia no disco,podendo assim, serem descartadas pelo processo.• Listas de páginas modificadas (sujas): contêm as páginas que tambémforam recentemente removidas do working set de algum processo, masainda estão associadas a ele. Essas páginas porém não possuem umacópia atualizada no disco.• Listas de páginas livres: contém as páginas que não estão associadas anenhum processo.• Listas de páginas zeradas: contém as páginas que também não estãoassociadas a nenhum processo, mas estão preenchidas com zero.• Listas de páginas com defeito físico: contém as páginas que estãorelacionadas com alguma porção de memória RAM que apresenta defeito.• Essa lista garante que tais páginas não serão mais acessadas.
  53. 53. 3.3.4 Tradução de EndereçosA tradução de um endereço virtual em um endereço físico é realizada daseguinte forma. Inicialmente, utilizando a parte mais significativa do endereçovirtual (índice de diretório de páginas), o diretório de páginas é acessado paradeterminar qual tabela de páginas está associada ao endereço virtual que sedeseja traduzir. Uma vez definida a tabela de páginas, o índice de tabela depáginas é empregado para determinar a página correspondente a esse endereçovirtual. A entrada da tabela de páginas fornece informações de controle e alocalização em memória da página a ser acessada (se presente). Finalmente, oíndice de byte é somado ao endereço inicial da página em memória, resultando noendereço físico correspondente ao endereço virtual desejado. A Figura 12apresenta a relação entre esses três valores e a forma pela qual eles sãoutilizados para mapear um endereço virtual em endereço físico.
  54. 54. Figura 12: Esquema de tradução de endereço virtual para endereço físico em arquiteturas IntelCada processo possui um único diretório de página para mapear alocalização das tabelas de paginas pertencentes a esse processo. O diretório depáginas possui 1024 entradas o que limita o numero máximo de tabelas depáginas de um processo. As tabelas de paginas são criadas sob demanda; porconseqüência, normalmente, muitas das entradas do diretório de paginas não sãoválidas. Cada tabela de página possui, por sua vez, também 1024 entradas, o que,de forma análoga, limita a quantidade de páginas por tabela de páginas. Otamanho de cada entrada, tanto do diretório de paginas quanto da tabela de
  55. 55. paginas, é de 4 bytes. Isso implica que cada uma dessas estruturas ocupem 4 KBde memória, ou seja, exatamente uma página. Essas tabelas são armazenadas noespaço de endereçamento virtual do processo, na área destinada ao sistemaoperacional, e sua localização exata é mantida no descritor de processo.3.3.5 Tratamento de Falta de PáginaUma referência a uma página inválida é chamada falta de página. Omanipulador de trap do kernel despacha esse tipo de falta para o manipulador defalta do gerenciador de memória (MmAccessFault) resolver. Essa rotina éexecutada no contexto da thread que incorreu na falta e é responsável por tentarresolver a falta (se possível) ou levantar uma exceção apropriada.Páginas no Windows NT variam de 4 KB à 64 KB, dependendo daarquitetura. O Pentium, por exemplo, utiliza 4 KB. O algoritmo de paginação doWindows NT é baseado por demanda com clustering (em grupos). Quando ocorreuma falta de página, o gerenciador de memória carrega na memória a página quefaltava e mais um pequeno número de páginas ao seu redor. Essa estratégia visaminimizar a taxa de faltas, explorando o princípio de localidade.Quando um processo é iniciado, são trazidas páginas para a memória amedida que ocorrem faltas de páginas. Essas faltas ocorrem quando:• A página referenciada não está commited.• A página está commited, mas não está mapeada.
  56. 56. • Uma página compartilhada foi escrita.• Ocorreu uma violação de proteção.• A pilha precisa crescer.3.3.6 Descritores de Endereço VirtualAnteriormente nós descrevemos as políticas de paginação que ogerenciador de memória virtual usa para determinar quando uma página deve sertrazida para a memória, onde colocá-la e que páginas remover quando a memóriase esgota.O gerenciador de memória virtual usa um algoritmo de paginação pordemanda para saber quando carregar páginas para a memória. Ele espera atéque alguma thread use um endereço e incorra em uma falta de página para depoisrecuperar uma página do disco. Este tipo de paginação por demanda é uma formade avaliação preguiçosa. Os algoritmos de avaliação preguiçosa evitam executaruma operação dispendiosa, como a paginação, até que ela seja absolutamentenecessária.O gerenciador de memória virtual usa a avaliação preguiçosa em uma outraárea, aquela da construção de tabelas de páginas. Por exemplo, quando umathread aloca uma grande região de memória virtual, o gerenciador de memóriavirtual poderia construir imediatamente as tabelas de páginas necessárias paraacessar toda a faixa de memória alocada. Entretanto, se a aplicação não usa toda
  57. 57. a memória alocada, a construção das tabelas de páginas é um esforço inútil.Conseqüentemente, o gerenciador de memória virtual espera para construí-lassomente quando uma thread incorre em uma falta de página. O uso da avaliaçãopreguiçosa desta maneira resulta em ganho significativo de desempenho para asaplicações que reservam muita memória, mas raramente a usam.Alocar memória, mesmo grandes blocos de memória, é extremamenterápido com o algoritmo de avaliação preguiçosa. No entanto, o ganho dedesempenho também tem suas desvantagens. Quando uma thread alocamemória, o gerenciador de memória virtual tem de responder com uma faixa deendereços virtuais que a thread poderá usar. Contudo, como o gerenciador dememória virtual só carrega a tabela de páginas do processo quando a threadacessa a memória, ele não tem condições de examinar a tabela de páginas paradeterminar que endereços virtuais estão livres. Portanto, o gerenciador dememória virtual precisa manter um outro grupo de estruturas de dados pararegistrar que endereços virtuais já foram alocados no espaço de endereçamentodo processo e quais ainda não foram. Os descritores de endereço virtual atendemesta necessidade.Para cada processo, o gerenciador de memória virtual mantém um conjuntode descritores de endereço virtual que descrevem o status do espaço deendereçamento virtual do processo.Quando um processo aloca memória (ou mapeia uma visão de memóriacompartilhada), o gerenciador de memória virtual cria um descritor de endereço
  58. 58. virtual para armazenar qualquer informação fornecida na solicitação de alocação,como a faixa de endereços que está sendo alocada, se a faixa será memóriacompartilhada ou privativa, se um processo filho pode herdar o conteúdo da faixa,e a proteção aplicada às páginas daquela faixa. Depois ele insere o descritor deendereço virtual em uma árvore específica do processo (uma árvore bináriaequilibrada) para acelerar sua localização.Quando uma thread acessa um endereço pela primeira vez, o gerenciadorde memória virtual precisa criar uma entrada na tabela de páginas para a páginaque contém o endereço. Para tanto, ele localiza o descritor de endereço virtualcuja faixa de endereço também contém o endereço acessado e usa a informaçãoencontrada para preencher a entrada na tabela de páginas. Se o endereço estiverfora da faixa coberta pelo descritor de endereço virtual, o gerenciador de memóriavirtual saberá que a thread não alocou este endereço de memória antes de usá-lo.Ocorre então, uma violação de acesso.3.4 Chamadas ao SistemaO Win32 API contém um numero de funções que permitem que um processogerencie sua própria memória virtual. Essas funções operam sobre uma seqüênciade duas ou mais páginas consecutivas no espaço de endereçamento virtual. AFigura 13 mostra algumas dessas funções.
  59. 59. Função API Win 32 DescriçãoVirtualAlloc Reserva ou commit uma regiãoVirtualFree Libera ou uncommit uma regiãoVirtualProtect Altera a proteção de leitura/escrita/execução de uma regiãoVirtualQuery Pergunta sobre o estado de uma regiãoVirtualLock Torna uma região residente em memóriaVirtualUnlock Torna a região paginável, da maneira usualCreateFileMappingCria um objeto de mapeamento de arquivo e (opcionalmente)atribui um nome a eleMapViewOfFile Mapeia um arquivo, ou parte dele, no espaço deendereçamentoUnmapViewOfFile Remove um arquivo mapeado do espaço de endereçamentoOpenFileMapping Abre um objeto de mapeamento de arquivo criadoanteriormenteFigura 13: Principais funções API Win32 para gerenciamento da memória virtual
  60. 60. 4. GERÊNCIA DE PROCESSOS4.1 Caracterização de Jobs, Processos, Threads e FibersUm Job pode ser considerado como uma coleção de um ou mais processosque irão ser gerenciados como uma única unidade, compartilhando certosatributos, além de prover restrições de segurança nos processos que estão noJob.Como no Unix, um processo pode ser considerado uma instância emexecução de um programa. Ele tem um espaço de endereçamento privadocontendo seu código e dados. Enquanto ele é executado, o sistema operacionalpode alocar recursos do sistema como semáforos e portas de comunicação. Umprocesso tem de ter no mínimo uma Thread, pois a Thread é a unidade a serescalonada pelo kernel.Um processo executando no modo usuário invoca o sistema operacionalatravés das chamadas de sistema. Através do sistema de traps, o seu modo deexecução passa a ser o modo do sistema (privilegiado) e então ele entra eexecuta no sistema operacional e após a execução ele retorna ao modo usuário.Processos também são representados como objetos, então eles sãomanipulados através do serviço de gerenciamento de processos, como mostra afigura 14. O processo tem uma prioridade base usada para o escalonamento dasThreads e uma afinidade com um processador padrão, que indica o conjunto deprocessadores no qual as Threads desse processo irão rodar. O quota limitespecifica a quantidade máxima de memória paginada e não-paginada e tempo deprocessador. O tempo total de CPU e os recursos utilizados pelo processo sãocontados em tempo de execução, assim como os contadores de E/S e oscontadores de operação da máquina virtual.
  61. 61. Figura 14: Representação de um processo como objetoUm processo pode criar múltiplas Threads para executar no seu espaço deendereçamento e ambos os objetos do processo e objetos das Threads possuemcapacidade de sincronização embutida. Threads são executadas no modo usuáriodurante grande parte do tempo, mas ao realizar uma chamada ao sistema, elasrodam no modo kernel, retendo suas características anteriores. Para administrar amudança de modo de execução, cada Thread possui duas pilhas, uma usada nomodo usuário e outra usada no modo kernel. Uma vez que uma Thread tenha sidocriada ela é gerenciada de forma independente a seu processo pai, pois nãoexiste nenhuma forma de hierarquia entre os processos no Windows NT. A figura15 mostra o objeto que representa uma Thread. O ID do cliente identifica uma
  62. 62. Thread de forma única. O contexto da Thread inclui o estado de memória daThread e o seu estado de execução. Outro fato importante de salientar é quesomente a Thread tem um indicador do estado da execução, visto que ela é aunidade básica a ser escalonada.Figura 15: Representação de uma Thread como um objetoTambém existe uma forma de Thread leve, que é chamada de Fiber. Aocontrário de Threads, Fibers são totalmente gerenciadas no modo usuário e sãoinvisíveis para o kernel. O Kernel gerencia as Threads e uma Thread em execuçãopode cooperativamente mudar de uma Fiber para outra através da diretivaSwitchToFiber. Cada Fiber tem um registro de estado associado, uma pilha,informação de tratamento de exceções e o valor de dado da Fiber. Essegerenciamento de escalonamento no nível de usuário significa que para ofuncionamento das Fibers é necessário cuidado. Se um bloco de uma Fiber em
  63. 63. execução é bloqueado, toda a Thread é bloqueada. Uma aplicação utilizandofibers só pode aproveitar o poder de multiprocessamento caso exista mais de umaThread no processo, e precisará ter controle de concorrência, pois pode ocorrer dediversas threads tentarem ceder a execução para uma Fiber. Uma aplicação quedeseja usar Fibers deve utilizá-la explicitamente através do comandoConvertThreadToFiber.4.2 Técnicas de comunicaçãoExistem diversas técnicas para a comunicação entre threads, sendo algumadelas as pipes, pipes nomeados, mailsots, sockets, chamadas remotas deprocedimento e arquivos compartilhados.Pipes tem dois modos de operação, byte e mensagem, selecionados emtempo de criação. O modo de byte funciona de forma análoga ao Unix, e o modode mensagem preserva os limites de cada uma das mensagens. Pipes nomeadosfuncionam como pipes comuns, mas com suporte a uso na rede.Mailslots tem funcionamento similar ao de pipes, mas com algumasdiferenças, como é uma técnica de comunicação unidirecional, enquanto pipessão bidirecionais. Mailslots tem suporte a transmissão via rede, mas sem garantiade entrega da mensagem. Outra característica importante é que mailslotspermitem a transmissão de uma mensagem para diversos destinatários.Sockets tem principal utilização na conexão de processos em máquinasdiferentes (remotas). Sockets podem até ser utilizados para conectar processosna mesma máquina, mas devido a ter um overhead mais alto que pipes, suautilização fica mais restrita ao contexto de uma rede.A chamada de procedimentos remotos é uma maneira de comunicação quepermite que um processo tenha acesso ao espaço de endereçamento de outroprocesso. Esta técnica tem restrições nos parâmetros, visto que seria inútilrepassar um ponteiro para um processo diferente.
  64. 64. Arquivos compartilhados são simplesmente áreas de memóriacompartilhada entre processos, possibilitando que um processo altere e outro leiaas informações em uma área de memória especificada.4.3 Técnicas de sincronizaçãoAssim como as técnicas de comunicação entre os processos, existemdiversas técnicas de sincronização, para prover uma alternativa viável para cadatipo de situação. Algumas das técnicas de sincronização são semáforos, mutex,regiões criticas e eventos. Todas essas ferramentas são aplicáveis a threads, nãoa processos, visto que somente processos são escalonáveis.Semáforos são criados pela função CreateSemphore da API, que o iniciacom um valor e também determina o valor máximo. Semáforos são objetos dokernel e tem descritores de segurança e handles. O handle para um semáforopode ser duplicado utilizando DuplicateHandle e então o semáforo pode serrepassado para outros processos, permitindo sua utilização em múltiplosprocessos.Mutex são objetos do kernel utilizados para sincronização, mas com umaestrutura mais simples do que semáforos devido a ausência de contadores.Funcionam essencialmente com duas operações da API, WaitForSingleObject(responsável pelo bloqueio) e ReleaseMutex (responsável pela liberação). Oshandles do mutex também podem ser duplicados, possibilitando o uso de ummutex para controle de threads em processos diferentes.Seções críticas são similares a mutex, mas são locais em relação a threadque as criou, ou seja, não são objetos do kernel, não tendo descritores desegurança ou handles, logo só são vistas por um processo. O bloqueio e aliberação são realizadas pelas funções EnterCrticalSection e LeaveCriticalSection,respectivamente. Devido a essas funções da API serem executadas no espaço dousuário e somente realizarem chamadas ao kernel quando é necessário realizar obloqueio, essa técnica é mais rápida que mutex.
  65. 65. O último tipo de sincronização são os eventos, que podem ser de dois tipos,eventos de reset manual ou eventos de reset automático. Um evento pode estarem dois estados, setado ou livre. Uma thread pode esperar por um evento atravésda função WaitForSingleObject. Se outra thread sinalizar um evento comSetEvent. O que ocorre após o evento ser setado depende do tipo de evento: emum evento de reset manual todos os threads na espera são liberados, o eventopermanece setado até que seja usado o comando ResetEvent; no caso com resetautomático, se uma ou mais threads estão esperando, somente uma thread éliberada, e o evento fica livre.4.4 Criação de Processos e ThreadsA criação de novos processos é realizada pela função CreateProcess,sendo uma forma mais complexa do que a criação de processos em Unix, devidoao fato dessa função levar dez parâmetros, que são citados a seguir:1. Um ponteiro para o nome do arquivo executável.2. A própria linha de comando.3. Um ponteiro para o descritor de segurança do processo.4. Um ponteiro para o descritor de segurança da thread inicial.5. Um bit que define se o processo herda o handle do criador.6. Diversos flags.7. Um ponteiro para strings do ambiente.8. Um ponteiro para o nome do diretório atual do novo processo.9. Um ponteiro para a estrutura que descreve a janela inicial na tela.10. Um ponteiro para a estrutura que retorna 18 valores para orealizador da chamada.Apesar de não haver hierarquia entre os processos, um dos valoresretornados ao realizador da chamada é o handle do novo processo, assim épossível uma hierarquia implícita entre os processos.
  66. 66. A criação de threads por sua vez é relativamente menos complexa que acriação de processos, utilizando a função CreatThread e tendo somente 6parâmetros, descritos a seguir:1. O descritor de segurança opcional.2. O tamanho inicial da pilha.3. O endereço inicial.4. Um parâmetro definido pelo usuário.5. O estado inicial da Thread (pronta ou bloqueada).6. O ID da Thread.4.5 EscalonamentoO escalonamento não é realizado por uma thread de escalonamentocentral. O sistema de escalonamento consiste em quando uma thread deixa de serapta à execução, ela entre no modo do kernel e executa o escalonador paradecidir qual a thread que será executada. Existem três situações que podemocorrer para uma thread deixar de ser apta a execução:1. A thread é bloqueada por uma ferramenta de sincronização.2. A thread interage com outro objeto.3. O quantum da thread em questão expira.No primeiro caso, a thread já estará rodando no modo do kernel, logo ela sódeve salvar seu contexto, acionar o escalonador e escolher o seu sucessor queserá carregado.No segundo caso, a thread também já estará executando no modo dokernel, mas sua interação poderá não resultar no seu bloqueio, logo a thread deveexecutar o escalonador para descobrir se sua ação não causou a liberação deuma thread com prioridade maior, pois se isso ocorrer ela deverá ceder a vez.No terceiro caso, um trap para o modo do kernel ocorre, e então a threadexecutará o escalonador, mas dependo do estados das outras threads, a mesmathread poderá ser selecionada para ser executada, recebendo um novo quantum,caso contrário será escolhida outra thread.
  67. 67. O escalonador também poder ser chamado em duas outras ocasiões:1. Quando uma operação de E/S é terminada.2. Quando um tempo de espera termina.Quando uma operação de E/S é terminada, uma thread poderá ser liberada,logo é necessário a execução do escalonador para determinar se essa thread queserá liberada poderá ser executada.Na segunda situação, uma thread que estava bloqueada tem seu tempo deespera esgotado, tornando-se apta para a execução novamente e assim énecessária a execução do escalonador.O sistema de escalonamento leva em conta um sistema de prioridades com32 níveis, que variam de 0 a 31, sendo que existe a prioridade base, que édeterminada de acordo com a Figura 16. E também existe a prioridade atual doprocesso, que nunca poderá ser menor do que o valor da prioridade base, maspoderá ser maior de acordo com as situações ocorridas no sistema.Figura 16: Tabela de prioridades do Windows 2000
  68. 68. 5. SISTEMA DE ARQUIVOSEste capítulo tem por objetivo apresentar o sistema de arquivos do WindowsNT e os formatos que são suportados pelo mesmo. Serão descritos os tipos desistemas de arquivo e como eles interagem com os demais componentes dosistema operacional, como o gerenciador de memória e o gerenciador de cache,por exemplo. Também será analisado o formato padrão do sistema de arquivos doNT, denominado NTFS. Tendo sido projetado do zero, não é um aperfeiçoamentode sistemas de arquivos antigos, e portanto não é sobrecarregado pelanecessidade de ser totalmente compatível com os sistemas de arquivos do MS-DOS.5.1 Conceitos Fundamentais do NTFSO Windows NT suporta vários sistemas de arquivos, entre eles a FAT-16 (FileAllocation Table - 16), FAT-32 (File Allocation Table - 32), NTFS (New TechnologyFile System), CDFS (CD-Rom File System), UDF (Universal Disk Format). A FAT-16 é um sistema de arquivos que usa endereços de 16 bits, limitando as partiçõesde disco em tamanhos de no máximo 2 GB. A FAT-32 é um sistema similar a FAT-16 que usa endereços de 32 bits, podendo ter uma partição de até 2 TB(Terabytes). Por sua vez, o NTFS utiliza endereços de 64 bits, podendo assimsuportar partições de até 16 EB (Exabytes), embora outros fatores a limitem a umtamanho menor.Tendo sido projetado do zero, o sistema de arquivos NTFS não é umaperfeiçoamento de sistemas de arquivos antigos, e portanto não ésobrecarregado pela necessidade de ser totalmente compatível com os sistemasde arquivos do MS-DOS.Os nomes de arquivos no NTFS são limitados a 255 caracteres; os caminhosdesde a raiz são limitados a 32767 caracteres. Esses nomes estão em Unicode, oque permite que pessoas de países que não usam o alfabeto latino utilizem nomes
  69. 69. de arquivos em seu idioma nativo. O NTFS diferencia totalmente letras maiúsculasde minúsculas, mas a API Win32 não, nem para nomes de arquivos nem paranomes de diretórios, fazendo com que programas que se restrinjam a usar oWin32, para compatibilizar com o Windows 98, percam esta vantagem.Os arquivos NTFS não são apenas seqüências lineares de bytes, como o queacontece com os arquivos no Unix e no FAT-32. Eles são formados por váriosatributos, representados por fluxos (streams) de bytes. A maioria dos arquivos éformada por alguns fluxos curtos, como nome de arquivo, ID de objeto de 64 bits,e mais um fluxo longo, sem nome, com os dados. Entretanto, um arquivo pode terdois ou mais fluxos de dados. Cada fluxo tem um nome formado pelo nome doarquivo, seguido de dois pontos e o nome do fluxo, como nomeDoArquivo:fluxo1.Cada fluxo tem seu próprio tamanho e pode ser impedido independentemente dosoutros fluxos. Essa idéia de múltiplos fluxos foi importada do Apple Macintosh, noqual os arquivos têm dois fluxos, os dados e os recursos. Esse conceito foiincorporado ao NTFS para permitir que um servidor utilizando esse tipo de sistemade arquivo seja capaz de servir clientes Macintosh.Os fluxos de arquivos servem para outros propósitos além da compatibilidadecom o Macintosh. Por exemplo, um programa de edição de fotos poderia usar ofluxo sem nome para a imagem principal e um fluxo com nome para a versãomenor, apenas para visualização. Outro uso dos fluxos dá-se no processamentode textos. Esses programas freqüentemente fazem duas versões de umdocumento; uma temporária, para usar durante a edição e outra final para quandoo usuário terminar de editar. Com a temporária em um fluxo com nome e a finalem fluxos sem nome, ambas as versões compartilham automaticamente o mesmonome de arquivo, a mesma informação de segurança, os mesmos indicadores detempo, etc., sem trabalho adicional.Ponteiros de arquivos são usados para acompanhar onde um processo estáem cada fluxo. Esses ponteiros têm 64 bits de largura para tratar o tamanhomáximo de um fluxo, que é cerca de 18,4 Exabytes.O NTFS é um sistema hierárquico de arquivos, semelhante ao Unix. Oseparador entre os nomes dos componentes é , característica herdada do MS-
  70. 70. DOS. Há o conceito de diretório de trabalho atual e os nomes de caminhos podemser tanto relativos quanto absolutos. Também são suportadas ligações rígidas esimbólicas; as primeiras são implementadas por entradas múltiplas de diretório,como no Unix; as últimas são implementadas usando pontos de reanálise. Alémdisso, compressão, criptografia e tolerância a falhas também são suportados.5.2 Chamadas de APIAs principais funções da API Win32 para gerenciamento de arquivos estãolistadas na Figura 17. Na verdade existem muito mais funções, mas essas sãosuficientes para que se compreenda a base do sistema.Função API Win 32 UNIX DescriçãoCreateFile open Cria um arquivo ou abre um arquivoexistente; retorna um handleDeleteFile unlink Deleta um arquivo existenteCloseHandle close Fecha um arquivoReadFile read Lê dados de um arquivoWriteFile write Escreve dados em um arquivoSetFilePointer Iseek Seta o ponteiro de arquivo em um lugarespecífico no arquivoGetFileAttributes stat Devolve as propriedades do arquivoLockFile fcntl Tranca uma região do arquivo paraprovidenciar exclusão mútuaUnlockFile fcntl Destrava uma região do arquivo previamentetravadaFigura 17: Principais funções API Win32 para funções de arquivosNão é explicado os parâmetros de todas as funções por serem muitos, porexemplo, os parâmetros para criação de um arquivo(CreateFile) são os seguintes:• Um ponteiro para o nome do arquivo a ser criado ou aberto.• Flags indicando se o arquivo pode ser lido, escrito ou ambos.• Flags indicando se múltiplos processos podem abrir o arquivo ao mesmotempo.• Um ponteiro para o descritor de segurança dizendo quem pode acessar o

×