Sistemas Operacionais 1 - Professor Sérgio Godoy
Propaganda
Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Curso Técnico Concomitante ou Sequencial de Manutenção e Suporte em Informática Material de Estudo Disciplina: Sistemas Operacionais 1 Professor: Sérgio Augusto Godoy Agosto/2009 1 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Índice Introdução aos Sistemas Operacionais ................................................................................. 7 Conceitos Básicos ................................................................................................................. 8 Máquina de Níveis ............................................................................................................. 8 Histórico ................................................................................................................................ 8 Primeira Fase 1945-1955 .................................................................................................. 8 Segunda Fase 1956-1965 ................................................................................................. 8 Processamento Batch .................................................................................................... 9 Terceira Fase 1966-1980 ................................................................................................... 9 Quarta Fase 1981-1990 ................................................................................................... 10 Quinta Fase 1991-2000 ................................................................................................... 10 Característica de cada fase ............................................................................................. 10 Conceitos de Hardware e Software ..................................................................................... 11 Hardware ......................................................................................................................... 11 Unidade Central de Processamento ............................................................................. 11 Clock ............................................................................................................................ 11 Registradores ............................................................................................................... 11 Memória Principal ............................................................................................................ 11 Memória Cache ............................................................................................................ 12 Memória Secundária .................................................................................................... 12 Dispositivos de Entrada e Saída ...................................................................................... 12 Barramento ...................................................................................................................... 12 Pipelining ......................................................................................................................... 12 Ativação/Desativação do Sistema.................................................................................... 12 Arquiteruras ..................................................................................................................... 13 Software .............................................................................................................................. 13 O que é um Sistema Operacional ?..................................................................................... 13 O Sistema Operacional como uma Máquina Virtual ........................................................ 13 O Sistema Operacional como um Gerenciador de Recursos .......................................... 14 Tradutor ........................................................................................................................... 14 Interpretador .................................................................................................................... 14 Linker ............................................................................................................................... 14 Loader (Carregador) ...................................................................................................... 14 Depurador ........................................................................................................................ 14 Linguagem de Controle .................................................................................................... 14 Linguagem de Máquina ................................................................................................... 15 Microprogramação ........................................................................................................... 15 Evolução Histórica dos Sistemas Operacionais .................................................................. 15 Estrutura do Sistema Operacional ....................................................................................... 15 A História do Sistema Operacional LINUX ....................................................................... 16 Conceito de Linux......................................................................................................... 16 Gerenciamento de Memória ......................................................................................... 16 Escalonamento............................................................................................................. 17 Políticas de Escalonamento ......................................................................................... 17 2 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Sistema de Arquivos Unificado..................................................................................... 18 Conceitos Fundamentais .............................................................................................. 18 Tipos de arquivos ......................................................................................................... 18 Diretórios ...................................................................................................................... 18 Conta ............................................................................................................................ 19 Arquivos Compartilhados ............................................................................................. 19 Sistema de Arquivos no Linux - Descrição ...................................................................... 19 Sistema de Arquivos Linux .............................................................................................. 20 Sistema de Arquivos Second Extended File System (ext2) ......................................... 20 Partição EXT3 (Linux Native) ....................................................................................... 21 I/O no Sistema de Arquivos do Linux ............................................................................... 21 Segurança ....................................................................................................................... 22 SAMBA - Compartilhamento de arquivos ........................................................................ 22 SQUID – Acesso à Internet .............................................................................................. 23 CUIDADOS ESPECIAIS .................................................................................................. 23 Windows 2003 ..................................................................................................................... 23 Gerência de Memória ...................................................................................................... 24 Sistema de Arquivos ........................................................................................................ 25 Windows XP ........................................................................................................................ 26 Mac OS X ............................................................................................................................ 27 Descrição ......................................................................................................................... 28 Versões ............................................................................................................................ 29 Sistema de Arquivos ........................................................................................................ 29 O Sistema Operacional UNIX .............................................................................................. 31 Uma Visão Geral do Sistema Operacional UNIX ............................................................. 31 Sistema de Arquivos ........................................................................................................ 31 CONCLUSÃO ...................................................................................................................... 32 Licenças .............................................................................................................................. 32 GNU General Public License ........................................................................................... 32 Licença Comercial ........................................................................................................... 33 Licença de software livre ................................................................................................. 34 Tipos de Sistemas Operacionais ......................................................................................... 34 Sistemas Monoprogramáveis/Monotarefa ....................................................................... 34 Sistemas Multiprogramáveis/Multitarefa .......................................................................... 34 Sistemas Batch ................................................................................................................ 35 Sistemas de Tempo Compartilhados (Time-Sharing) ................................................... 35 Sistemas Tempo Real...................................................................................................... 35 Sistemas com Múltiplos Processadores .......................................................................... 35 Sistemas Fortemente Acoplados ..................................................................................... 35 Sistemas Assimétricos ................................................................................................. 35 Sistemas Simétricos ..................................................................................................... 35 Multiprocessamento ..................................................................................................... 36 Organização Funcional ................................................................................................ 36 BARRAMENTO COMUM ............................................................................................. 36 3 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS BARRAMENTO CRUZADO ......................................................................................... 37 MEMÓRIA MULTIPORT............................................................................................... 37 Sistemas Fracamente Acoplados .................................................................................... 37 Sistemas Operacionais de Rede (SOR) .......................................................................... 38 SISTEMAS OPERACIONAIS DE REDE ...................................................................... 38 Sistemas Operacionais Distribuídos ............................................................................. 39 CLUSTER..................................................................................................................... 39 Organização Funcional .................................................................................................... 40 ORGANIZAÇÃO BARRAMENTO .................................................................................... 40 ORGANIZAÇÃO DISTRIBUÍDA ................................................................................... 40 Histórico dos Sistemas Operacionais .................................................................................. 41 Tipos de Sistemas Operacionais ......................................................................................... 42 Sistemas Monoprogramáveis/Monotarefa ....................................................................... 42 Sistemas Multiprogramáveis/Multitarefa .......................................................................... 42 Sistemas Multiprogramáveis ............................................................................................ 43 Interrupção e Exceção ................................................................................................. 44 Mecanismo de Interrupção ........................................................................................... 44 Operações de Entrada/Saída........................................................................................... 45 Controlador ou Interface ............................................................................................... 45 CANAL DE E/S............................................................................................................. 46 Buffering .......................................................................................................................... 46 Operações usando o Buffer.......................................................................................... 46 Estágios da técnica de Buffering .................................................................................. 47 Spooling (Simultaneous peripheral operation on-line) .................................................. 47 Reentrância .................................................................................................................. 47 Proteção do Sistema........................................................................................................ 47 Sistema Multiprogramável/Multitarefa ................................................................................. 47 Sistemas BATCH ............................................................................................................. 48 Sistemas de Tempo Compartilhado ................................................................................. 48 Sistemas de Tempo Real ................................................................................................. 48 Sistemas com Múltiplos Processadores .......................................................................... 49 Tipos de Sistemas com Múltiplos Processadores ........................................................ 49 Sistemas Multiprogramáveis ............................................................................................ 50 Interrupção e Exceção ................................................................................................. 51 Buffer............................................................................................................................ 52 SPOOL ......................................................................................................................... 52 Reentrância .................................................................................................................. 52 Segurança e Proteção do Sistema ............................................................................... 53 Operações de Entrada e Saída .................................................................................... 53 Estrutura do Sistema Operacional ....................................................................................... 56 Funções do Sistema ........................................................................................................ 56 System Calls .................................................................................................................... 57 Modos de Acesso ......................................................................................................... 58 Arquiteturas: Sistemas monolíticos, em camadas e microkernel ................................. 58 4 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS PROCESSO ........................................................................................................................ 61 Modelo de Processos ...................................................................................................... 61 Concorrência ................................................................................................................ 62 Regiões Críticas ........................................................................................................... 62 Mútua Exclusão Com Espera Ocupada ....................................................................... 63 Desabilitar Interrupções ............................................................................................... 63 Variáveis LOCK ............................................................................................................ 63 Alternância Estrita ........................................................................................................ 63 Mútua Exclusão com Espera Bloqueada ...................................................................... 63 Sleep e Wakeup ........................................................................................................... 63 Semáforos .................................................................................................................... 64 Contadores de Evento .................................................................................................. 64 Monitores...................................................................................................................... 64 Comunicação Inter-processos ...................................................................................... 64 Passagem de Mensagem ............................................................................................. 65 Compartilhamento de Dados ........................................................................................ 65 Chamada de Procedimentos Remotos ......................................................................... 65 Processos e Threads........................................................................................................... 65 Contexto de um Processo ................................................................................................... 66 Estados de um Processo ..................................................................................................... 66 Estados de Execução de um Processo ............................................................................... 67 Sincronização de Processos ............................................................................................ 67 Problemas de Sincronização ........................................................................................... 67 Deadlock .......................................................................................................................... 68 Escalonamento de Processos ............................................................................................. 68 Escalonamento de Processos ............................................................................................. 69 Algoritmos de Escalonamento ............................................................................................. 69 Escalonamento Round Robin .......................................................................................... 69 Algoritmos com Prioridades ............................................................................................. 69 Múltiplas Filas .................................................................................................................. 70 Tarefas Pequenas Primeiro ............................................................................................. 70 Algoritmo “Policy-Driven” ................................................................................................. 70 Escalonamento em Dois Níveis ....................................................................................... 70 Semáforos ....................................................................................................................... 70 Componentes do processo .............................................................................................. 70 Estados do processo ....................................................................................................... 72 Mudanças de estado do processo................................................................................ 72 Tipos de processos .......................................................................................................... 73 Funções............................................................................................................................... 74 Critérios de escalonamento ............................................................................................. 74 Escalonamentos Não-Preemptivos e Preemptivos .......................................................... 74 GERENCIAMENTO DE MEMÓRIA ..................................................................................... 77 Gerenciamento de Memória Sem Permuta ou Paginação ............................................... 78 Monoprogramação ........................................................................................................... 78 5 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Multiprogramação e Uso da Memória .............................................................................. 78 Modelagem da Multiprogramação.................................................................................... 78 Multiprogramação com Partições Fixas ........................................................................... 78 Swapping (Permuta) ........................................................................................................ 79 Multiprogramação com Partições Variáveis ..................................................................... 79 Gerenciamento de Memória com Mapa de Bits ............................................................... 79 Gerenciamento de Memória com Listas Encadeadas ...................................................... 79 Gerência de Memória / Memória Virtual .............................................................................. 80 Funções ........................................................................................................................... 80 Alocação Contígua Simples ............................................................................................. 81 Segmentação de Programas ........................................................................................... 81 Alocação Particionada Estática........................................................................................ 82 Alocação Particionada Dinâmica ..................................................................................... 84 Estratégias de Alocação de Partição ............................................................................... 84 Swapping ......................................................................................................................... 84 Memória Virtual ................................................................................................................... 85 Paginação ........................................................................................................................ 85 Segmentação ................................................................................................................... 86 Algoritmos de Troca de Página ........................................................................................ 86 Troca Ótima de Página .................................................................................................... 86 Troca da Página Não Recentemente Usada (NRU) ........................................................ 86 Troca da Página FIFO ..................................................................................................... 87 Troca da Página Menos Recentemente Usada (LRU) ..................................................... 87 Algoritmos de substituição de páginas ............................................................................. 87 Gerência de Sistemas de Arquivos ..................................................................................... 88 Estrutura de Diretórios ..................................................................................................... 88 SISTEMA DE ARQUIVOS ............................................................................................... 88 Interface do Sistema de Arquivos ................................................................................. 88 Fundamentos Básicos .................................................................................................. 88 Diretórios ...................................................................................................................... 89 Confiabilidade do Sistema de Arquivos ........................................................................... 90 Blocos Defeituosos....................................................................................................... 90 Consistência do Sistema de Arquivos .......................................................................... 90 Desempenho do Sistema de Arquivos ......................................................................... 91 Sistemas de alocação de arquivos ...................................................................................... 93 ENTRADA/SAÍDA................................................................................................................ 93 Dispositivos de E/S .......................................................................................................... 93 Controladores de Dispositivos ......................................................................................... 94 BIBLIOGRAFIA.................................................................................................................... 96 6 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Introdução aos Sistemas Operacionais Consiste de um ou um conjunto de programas que compõem o software básico do computador e cuja finalidade é a de executar os programas aplicativos e de servir de interface entre o computador e seus usuários. Um sistema operacional deve atender a três objetivos principais: Conveniência - tornar o uso do computador mais conveniente (fácil). Eficiência - tornar eficiente (seguro e justo) o uso e o compartilhamento dos recursos existentes Evolução - possibilitar o constante debug e o desenvolvimento de novas funcionalidades Numa abordagem macro, o sistema operacional pode ser visto como a primeira camada de software acima do hardware do computador que, conforme mostra a figura abaixo, se encarrega de suportar e servir de interface entre este e os demais programas aplicativos e utilitários. Aplicativos Utilitários Sistema Operacional Hardware Visão do Sistema por Camadas Um sistema operacional hoje se constitui de diversos módulos que se encarregam da comunicação, alocação e gerenciamento de recursos específicos tais como: · Processo · Memória · Arquivos · Entrada e Saída · Interconexão · Alocação da UCP ("Scheduling") · Segurança e · Interface com o Usuário A interface entre os programas aplicativos (processos) e o sistema operacional é realizada através de comandos (instruções) de chamada do sistema ( as system calls). Estas chamadas estão geralmente disponíveis ao nível das linguagens assembly e, em geral, são introduzidas nos programas escritos em linguagens de mais alto nível, pelos respectivos compiladores. Grande parte dos programadores não tomam conhecimento das system calls, embora seus programas façam uso intenso delas. O fato é que muitos dos detalhes da interface com os sistemas operacionais são escondidos do programador pelos compiladores e pelo sistema de suporte a execução dos processos. A história mostra que os sistemas operacionais vêm sofrendo constantes modificações com o passar do tempo. No início eram relativamente simples, do tipo monousuário e praticamente não ofereciam qualquer mecanismo de proteção aos usuários. Com a evolução do hardware e o surgimento de 7 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS equipamentos cada vez mais velozes, os sistemas operacionais foram se tornando mais complexos, mais seguros, mais eficientes e mais abrangentes. Diversos tipos de sistemas operacionais podem ser identificados: monoprogramáveis, multiprogramáveis, multiprocessáveis, sistemas em rede, sistemas distribuidos, sistemas em lote ("batch"), sistemas de tempo compartilhado ("time sharing") e de tempo real. Conceitos Básicos * Sistema Operacional é um conjunto de rotinas executados pelo processador, da mesma forma que qualquer outro programa. *Sua Principal função é controlar o funcionamento do Computador. *Serve de interface entre o usuário e os recursos disponíveis no sistema. *Nos sistemas multiusuário o S.O. é responsável por permitir o acesso concorrente dos vários usuários. *Nos computadores pessoais o S.O. é responsável por controlar a execução concorrente de tarefas. Máquina de Níveis *Nos primeiros computadores, a programação era realizada em painéis, através de fios, exigindo um grande conhecimento do hardware e de sua linguagem de máquina. *O surgimento do S.O. tornou a interação entre usuário e o computador mais simples, confiável e eficiente. Usuário Sistema Operacional Hardware *Podemos considerar o computador como uma máquina de níveis ou camadas. nível 0hardware, nível 1S.O. Na realidade o computador possui tantos níveis quanto forem necessário, desta forma o usuário pode enxergar a máquina como sendo apenas o S.O. Aplicativos Utilitários Sistema Operacional Linguagem de Máquina Microprogramação Dispositivos Físicos Histórico Primeira Fase 1945-1955 *Primeiros computadores digitais, formados por milhões de válvulas, ocupavam grandes espaços e de funcionamento lento e duvidoso. *A programação era feita em painéis, através de fios, utilizando linguagem de máquina. *Não existia o conceito de S.O. Segunda Fase 1956-1965 *Criação do transistor e das memórias magnéticas. *Primeiras linguagens de programação Assembly e Fortran. *Primeiros S.O. para tentar automatizar as tarefas manuais. 8 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS *Processamento Batch, quando um lote de programas era submetido ao computador. Processamento Batch Cartões Perfurados Processamento Fita de Entrada Fita de Saída Fita de Entrada Fita de Saída Processamento Processamento Relatórios *Os S.O. passaram a ter seu próprio conj. de rotinas para operações de entrada/saída(Input/Output Control System-IOCS). *Conceito de Canal (Linha 7094 da IBM )Transferência de dados entre dispositivos de entrada/saída e memória principal de forma independente da UCP. *Sistemas FMS(Fortran Monitor System) e IBSYS Terceira Fase 1966-1980 *Série 360 da IBM-1964 *S.O. OS/360 *A evolução dos processadores de entrada /saída permitiu que, enquanto um programa esperasse por uma operação de leitura/gravação, o processador executasse um outro programa. Para tal, a memória foi dividida em partições, onde cada programa esperava sua vez para ser processado. A essa técnica de compartilhamento da memória principal e processador deu-se o nome de multiprogramação. *Spooling Com a substituição das fitas por discos no processo de submissão dos programas, o processamento Batch tornou-se mais eficiente, pois permitia a alteração na ordem de execução das tarefas, até então puramente seqüencial.( mais tarde viria a ser utilizado no processo de Impressão.) * Surgimento de terminais de vídeo e teclado (interação on-line) que permitem interação rápida entre usuário e computador. *Multiprogramação evolui preocupada comem oferecer aos usuários tempos de resposta razoáveis e uma interface cada vez mais amigável. Para tal, cada programa na memória utilizaria o processador em pequenos intervalos de tempo. A esse sistema de divisão de tempo do processador chamou-se Time-sharing (tempo compartilhado). 9 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS *Surgimento do S.O. Unix(1969) minicomputador PDP-7, baseado no Sistema MULTICS (Multiplexed information and Computing Service), foi escrito depois em linguagem C. *No final dessa fase surgiram os primeiros microcomputadores (8 bits da Apple e o S.O.CP/M (Control Program Monitor). Quarta Fase 1981-1990 *LSI (Large Scale Integration) VLSI (Very Large Scale Integration) integração em larga escalaminuaturização e barateamento dos equipamentos. *Surgem os PC de 16 bits da IBM *DOS (Disk Operation System). *Sistemas multiusuários Unix (Unix-Like) e o VMS (Virtual Memory System) da DEC. *Estações de trabalho (workstations) que apesar de monousuárias, permitem que se executem diversas tarefas concorrentes criando o conceito de multitarefa . *No final dos anos 80 foram adicionados outros processadores. Com o multiprocessamento foi possível a execução de mais de um programa simultaneamente ou até de um mesmo programa por mais de um processador. *As redes distribuídas (Wide Area Network- WANs) se difundiram por todo o mundo permitindo o acesso a outros sistemas de computação, independentemente de estado, país e fabricante. *Desenvolvidos inúmeros protocolos de rede. DECnet da DEC , SNA da IBM TCP/IP de domínio publico e o CCITT X.25 *Surgem as LANs *S.O. de rede. Quinta Fase 1991-2000 *Conceito de processamento distribuído será explorado nos sistemas operacionais de forma que suas funções estejam espalhadas por vários processadores através de redes. *A arquitetura Cliente-Servidor aplicada basicamente a redes locais passa a ser oferecida em redes distribuídas, permitindo que qualquer pessoa tenha acesso a todo tipo de informação, independentemente de onde esteja armazenada. Problemas de segurança, gerência e desempenho tornam-se fatores importantes relacionados ao S.O. e à rede. *Consolidação dos S.O. baseados em interfaces gráficas. *ULSI (Ultra Large Scale Integration) Característica de cada fase FASE COMPUTADOR ES HARDWARE SOFTWARE Primeira 1945-1955 ENIAC EDVAC UNIVAC Segunda 1956-1965 NCR IMB 7094 CDC-6600 Válvulas Tambor Magnético Tubos de raios catódicos Ling. Máquina Transistor Memória magnética Ling. Alto Nível Terceira 1966-1980 IBM 360-370 PDP-11 Cray 1 Cyber-205 Circuito Integrado Disco magnético Minicomputador Microprocessador Quarta 1981-1990 Cray XMP IBM 308 VAX-11 IBM-PC LSI ou VLSI Disco óptico Microcomputador Quinta 1991-2000 IBM 3090 Alpha AXP Pentium Sun SPARC Ultra-LSI Arquiteturas paralelas Circ. Integrado 3-D Ling. Estruturadas Multiprogramação Multiprocessamento Sist. especialistas Processamento distribuído 10 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Ling. assembly Telefone Telecomunicações Teletipo 10 ips Processame Time -Sharing nto Batch Computação gráfica Ling. Orientadas a objetos Transmição Comunicação via digital Satélite Microondas Redes distribuídas (WAN) Fibra óptica Redes Locais(LAN) Internet 200.000 ips 30 Mips 5 Mips DESEMPENHO Ling. concorrentes Programação funcional Ling. Naturais Redes locais estendidas(ELA N) Redes sem fio Modelo ClienteServidor 1 Gflops 1 Tflops Conceitos de Hardware e Software Hardware *Todos os componentes de um computador são agrupados em três subsistemas básicos: unidade central de processamento, memória principal e dispositivos de entrada/saída. Estes subsistemas, também chamados Unidades Funcionais. Unidade Central de Processamento *Função principal unificar todo o sistema. *Execução de todos os programas do sistema, que estão obrigatoriamente armazenados na memória principal. *Executa seqüencialmente as series de instruções que compõe um programa. *Composta por 2 componentes básicos: º Unidade de controle UC controla atividades de todos os componentes do computador. º Unidade Lógica e Aritmética ULA operações lógicas (teste e comparação) e aritméticas (somas e subtrações). Clock *Localizado na UCP, gera pulsos elétricos síncronos em determinado tempo(sinal de clock) *Freqüência de clock Vezes que o pulso se repete em um segundo. Hertz (Hz). *pode ser utilizada como unidade de desempenho.(maior freqüência = maior instruções executadas pela UCP). Registradores *De alta velocidade localizados na UCP para armazenar temporariamente os dados. *Entre os registradores de uso específico, destacam-se: º Contador de instruções CI ou Program Counter PC armazenamento da próxima instrução. º Apontador da pilha AP ou Stack Pointer SP armazenamento de instruções que estavam sendo usadas e foram interrompidas por algum motivo. º Registrador de estado ou Program Status Word PSW informação sobre a execução do programa. Memória Principal *Onde são armazenados instruções e dados. *Composta por unidades de acesso - Células de (8bits) Byte. 11 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS *Endereço Especificação de um número de acesso ao conteúdo da célula, antes de um programa escrever ou ler um dado em uma célula, deve especificar um endereço de memória. *Registrador de endereço de memória As especificações do endereço é realizado por MAR (Memory Register Address) . A capacidade da memória é limitada pela MAR. *Registrador de dados da memória Guarda o Conteúdo de uma ou mais células de memória. MBR (Memory Buffer Register). *A memória principal pode ser classificada em função de sua volatividade. º RAM (Random Access Memory ) volátil. º ROM ( Read-Only Memory) não volátil. Memória Cache *Volátil de alta velocidade *Alto custo Memória Secundária *Não volátil. *Acesso lento. *Custo baixo *Grande capacidade de armazenamento. Dispositivos de Entrada e Saída *Comunicação entre o computador e o mundo externo *Divididos em: º Utilizados como memória secundária (Disquete). º Comunicação homem-máquina (Teclado). Barramento *Interliga memória principal, UCP e Disp. de entrada/Saída. *Bus Conj. de fios paralelos (linhas de transmissão) onde trafegam informações (dados, endereços, sinais de controle). *Unidirecional transmição em um só sentido *Bidirecional transmição em ambos sentidos *Barramento de dados Transmite informações entre memória princ.e UCP. *Barramento de endereços UCP especifica endereço dea célula de memória que será acessada. *Barramento de controle UCP envia os pulsos de controle relativos às operações de leitura e gravação. Pipelining * Semelhante a uma linha de montagem, onde cada tarefa é divida em seqüencia de subtarefas, executadas em diferentes estágios. *Pode ser empregada em sistemas com um ou mais processador em diversos níveis, tem sido a técnica de paralelismo mais utilizada para maior desempenho dos sistemas de computadores. Ativação/Desativação do Sistema *Boot Carrega o S.O. da memória secundária para a principal, realizado por um programa localizado no Boot block . *Shutdown Desativa o S.O. e componentes de forma ordenada. 12 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Arquiteruras Arquiteturas RISC (Reduced Instrution Set Computer) e CISC (Complex Instrution Set Computer) *RISC Poucas instruções de máquina. Bastante simples executadas diretamente pelo hardware. Na maioria não acessam a memória principal. Trabalho com registradores. Grande número de registradores. Ex. Sparc(SUN), RS 6000 (IBM), PA-RISC (HP), Alpha AXP (DEC) e Rx000 (MIPS). *CISC Instruções complexas interpretadas por microprogramas. Pequeno número de registradores. Qualquer instrução pode referencia a memória principal. Dificil a implementação Pepilining . Ex. VAX (DEC), 80x86 e o Pentium (Intel) e o 68xxx (Motorola). Software Programas computacionais (ou software) constituem o elo entre o aparato eletrônico (ou hardware) e o ser humano. Tal elo se faz necessário dada a discrepância entre o tipo de informação manipulada pelo homem e pela máquina. A máquina opera com cadeias de códigos binários enquanto o homem opera com estruturas mais abstratas como conjuntos, arquivos, algoritmos, etc. Qualquer computador moderno tem uma variedade de programas que fazem diversas tarefas. Eles podem ser classificados em duas grandes categorias: 1. Software de sistema que incluiu o firmware (O BIOS dos computadores pessoais, por exemplo), drivers de dispositivos, o sistema operacional e tipicamente uma interface gráfica que, em conjunto, permitem ao usuário interagir com o computador e seus periféricos. 2. Software aplicativo, que permite ao usuário fazer uma ou mais tarefas específicas. Aplicativos podem ter uma abrangência de uso de larga escala, muitas vezes em âmbito mundial; nestes casos, os programas tendem a ser mais robustos e mais padronizados. Programas escritos para um pequeno mercado têm um nível de padronização menor. O que é um Sistema Operacional ? A maioria de usuários de computador têm alguma experiência com sistemas operacionais, mas é difícil definir precisamente o que é um sistema operacional. Parte do problema decorre do fato do sistema operacional realizar duas funções básicas que, dependendo do ponto de vista abordado, uma se destaca sobre a outra. Estas funções são descritas a seguir. O Sistema Operacional como uma Máquina Virtual A arquitetura (conjunto de instruções, organização de memória, E/S e estrutura de barramento) da maioria dos computadores a nível de linguagem de máquina é primitiva e difícil de programar, especificamente para operações de entrada e saída. É preferível para um programador trabalhar com abstrações de mais alto nível onde detalhes de implementação das abstrações não são visíveis. No caso de discos, por exemplo, uma abstração típica é que estes armazenam uma coleção de arquivos identificados por nomes simbólicos. O programa que esconde os detalhes de implementação das abstrações é o sistema operacional. A abstração apresentada ao usuário pelo sistema operacional é simples e mais fácil de usar que o 13 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS hardware original. Nesta visão, a função do sistema operacional é apresentada a o usuário como uma máquina estendida ou máquina virtual que é mais fácil de programar que o hardware que a suporta. O Sistema Operacional como um Gerenciador de Recursos Um computador moderno é composto de vários subsistemas tais como processadores, memórias, discos, terminais, fitas magnéticas, interfaces de rede, impressoras, e outros dispositivos de E/S. Neste ponto de vista, o sistema operacional tem a função de gerenciar de forma adequada estes recursos de sorte que as tarefas impostas pelos usuários sejam atendidas da forma mais rápida e confiável possível. Um exemplo típico é o compartilhamento da unidade central de processamento (CPU) entre as várias tarefas (programas) em sistemas multiprogramados. O sistema operacional é o responsável pela distribuição de forma otimizada da CPU entre as tarefas em execução. Tradutor *Gera o Modulo-Objeto( Cód. de máquina ) *Montador (Assembler) diretamente ligada as características do processador. *Compilador Pode ser transportados entre computadores de diversos fabricantes, desde que exista regras para a definição da linguagem. Interpretador *Tradutor que não gera código-objeto. *Gasta mais tempo na tradução das instruções. Ex. Basic, o dBase eo APL. Linker *Gera a partir de um ou mais módulo-objeto um único programa executavel. *RelocaçãoDeterminar região de memória na qual o programa será carregado. Código Absoluto... S.O. antigos posição prefixiada na memória. Código Relocável... S.O. multiprogramaveis posição variável na memória. *Bibliotecas são arquivos que contêm diversos módulos-objeto e/ou definições de simbolos. Loader (Carregador) * Coloca fisicamente na memória um programa. *Loader absoluto *Loader relócavel Depurador *Controla a execução de um programa a fim de detectar erros na sua estrutura. *Acompanha a execução passo a passo. *Possibilita alterações e visualização do conteudo de variáveis *Implementa breakpoint pontos de parada dentro do programa. *Watcpointenvia mensagem toda vez que o conteudo de uma variável for modificado. Linguagem de Controle *Forma mais direta de comunicação entre o usuário e o S.O. *ShellInterpretador da linguagem de comando(Controle). 14 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Linguagem de Máquina *Linguagem que oprocessador entende. Microprogramação *Microprogramas definem a linguagem de máquina de cada computador. Evolução Histórica dos Sistemas Operacionais A evolução dos sistemas operacionais foi uma conseqüência dos avanços ocorridos no hardware dos computadores. Temos três níveis de gerações de sistemas operacionais: O primeiro nível integrado pelos sistemas operacionais básicos, surgidos nos anos cinqüenta, limitava-se a auxiliar os programas nas operações de entrada e saída e na tradução nos programas fonte, escritos em linguagem pouco evoluídas. O segundo nível esteve disponível na década de 60 e a sua ajuda à programação foi mais decisiva, proporcionando tradutores simbólicos mais evoluídos, programas de serviços para transferência de informação entre periféricos e programas de controle de entrada e saída, ou seja, os famosos IOCS( Input Output Control System). O terceiro nível de sistemas operacionais surgiu na década de 70. A contribuição destes sistemas à programação foi tão grande que foram rompidas as normas clássicas do processo informático. Os tradutores de altíssimo rendimento então incorporados têm permitido hoje em dia a utilização de linguagem de programação simbólica quase idênticas à linguagem utilizada pelo homem, reduzindo sensivelmente o tempo gasto na produção bem como o tempo de aprendizagem de novas linguagens. Estrutura do Sistema Operacional Pode-se criar um sistema tão grande e complexo como um sistema operacional somente dividindo-o em pequenas partes. Cada uma dessas partes deve ser uma porção bem delineada do sistema, com entradas, saídas e funções, cuidadosamente definidas. Logicamente, nem todos os sistemas têm a mesma estrutura, ou seja, não apresentam a mesma forma de ligação entre as partes. Contudo, os sistemas operacionais modernos geralmente possuem as seguintes partes: I. Gerenciamento de processos - criar e eliminar, suspender e retomar, sincronismo e comunicação entre processos; II. Gerenciamento da memória principal – manter o controle das partes da memória que estão sendo usadas e por quem, decidir que processos serão carregados para memória quando houver espaço disponível, alocar e desalocar espaço de memória quando necessário; III. Gerenciamento de memória secundária – o SO é responsável pelas atividades de alocação de espaço livre. IV. Gerenciamento de Entrada/Saída – manter os device drivers para comunicação com os deferentes dispositivos, um buffer-caching para o sistema; V. Gerenciamento de arquivos – criar e eliminar arquivos e diretórios, manter mapeamento dos arquivos em disco; VI. Proteção do sistema – se um sistema é multiusuário e permite múltiplos processos concorrentes, estes processos devem ser protegidos de outras atividades; VII. Networking – em um sistema distribuído (fracamente acoplado) cada processador tem sua própria memória e seus processadores que se comunicam através do SO. A comunicação entre eles deve considerar roteamento e estratégias de conexão; 15 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS VIII. Interpretador de comandos – um dos mais importantes programas do SO é o interpretador de comandos, que serve de interface entre o usuário e o SO. Alguns SO’s incluem este programa no próprio núcleo (kernel). Já outros sistemas, como o DOS e o UNIX, tratam o interpretador de comandos como um programa especial que é executado quando uma sessão é iniciada. Com isso, um sistema operacional fornece um ambiente para execução, melhor dizendo, fornece serviços para os programas e também para os usuários desses programas. A História do Sistema Operacional LINUX O Sistema Operacional Linux foi originalmente criado por Linus Torvalds na Universidade de Helsinki na Finlândia. Ele foi desenvolvido com a ajuda de vários programadores através da Internet. Linus teve seu projeto inspirado pelo seu interesse em Minix, um pequeno sistema Unix desenvolvido por Andy Tannenbaum. No dia cinco de Outubro de 1991, Linus anunciou a primeira versão "oficial'' de Linux, versão 0.02. Desde então, vários programadores responderam à sua chamada, e haviam ajudado a tornar Linux o completo sistema operacional que ele é hoje. Conceito de Linux Linux é um sistema operacional Unix independente, largamente distribuído para máquinas x86, Motorola 68k, Digital Alpha e Motorola PowerPC. Ele é uma implementação da especificação do POSIX com a qual todas as verdadeiras versões de Unix consentem. O núcleo de Linux não usa códigos de AT&T ou qualquer outra fonte de proprietário, e muitos dos softwares disponíveis para Linux são desenvolvidos pelo projeto Free Software Foundation's GNU. Enfim, é uma completa implementação do sistema operacional Unix. Como Unix, Linux é um multi-tarefa robusto, multiusuário, sistema operacional de rede que ostenta uma longa lista de padrões aceitáveis . Possui suporte completo para ambas plataformas de 32 e 64-bits, múltiplas CPUs e alta performance para redes e outros periféricos. Ele suporta uma vasta variedade de softwares, incluindo X Windows, Emacs e redes TCP/IP (incluindo SLIP/PPP/ISDN). Muitas pessoas já executaram marcas de nível em sistemas 80486 Linux e acharam elas comparáveis com estações de trabalho médias da Sun e Digital. O Sistema Operacional Linux está disponível na Internet em diversos sites, e também com várias versões em disquetes ou CD-ROM. A parte central de Linux é coberta pela GNU Public License (GPL), e é geralmente "empacotada" com vários binários que consistem em um sistema operacional trabalhando em Unix. Esses pacotes de softwares são chamados ―distribuições‖ e chegam em muitos tamanhos e estruturas. Linux está sendo usado hoje por milhões de pessoas em todo o mundo. Ele é usado para desenvolvimento de software, rede (intra-office e Internet), e como plataforma para usuário. Linux tornou-se uma alternativa barata para os caros sistemas Unix. Gerenciamento de Memória A execução do LMM (Linux Memory Manager) exige uma estratégia de paginação com uma copyon-write (copiado e marcado) confiando nas 386 páginas auxiliares. Um processo alcança suas tabelas de páginas de seu parent (durante um fork ) com as entradas marcadas como read-only ou trocado. Então, se o processo tenta escrever para este espaço de memória e a página é uma copy on write page, isto é copiado e a página marcada read-write. Um exec ( ) resulta na leitura de uma página ou mais do executável. O processo então erra em qualquer outra página que precisar. Cada processo tem uma tabela de página que significa que pode acessar 1 Kb de tabela de página indicando para 1 Kb de 4 Kb, páginas que é 4 Gb de memória. Um diretório de página do processo é iniciado durante um Fork por copy-page-tables. O processo inativo tem seu diretório de página inicializado durante a sequência de inicialização. Cada processo usuário tem uma tabela descritória 16 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS local que contém um código de segmento e um segmento de dados. Estes segmentos usuários extendem de 0 para 3 Gb (0 X c 0000000). Nos espaços usuários, endereços lineares e endereços lógicos são idênticos. No 80386, endereços lineares vão de 0 Gb para 4 Gb. Um endereço linear indica uma posição particular de memória dentro deste espaço. Um endereço linear não é um endereço físico --- isto é um endereço virtual. Um endereço lógico consiste de um seletor e um offset. O seletor indica para um segmento e o offset diz que distância na seção o endereço é localizado. O código Kernel e o segmento de dados são seções privilegiados definidos na tabela descritora global e extende de 3Gb para 4Gb. O Swapper - page - dir é organizado para que estes endereços lógicos e físicos sejam idênticos no espaço Kernel. Escalonamento O escalonador LINUX é baseado em time-sharing, ou seja, atua na divisão do tempo de processador entre os processos. O Scheduler é o programa encarregado de agendar os processos, isto é, ele deve escolher o próximo processo que vai rodar, deve decidir quando o tempo de um processo terminou, o que fazer com um processo quando ele requisita I/O e assim por diante. Ele é chamado de vários pontos do programa, como após colocar o processo corrente em uma fila de espera, no final de uma chamada de sistema ou qualquer outro momento em que se faz necessário escalonar os processos. Ao ser chamado, o scheduler tem uma seqüência de ações que devem ser tomadas para que seu trabalho possa ser feito. Essas ações se dividem em: Kernel Work: o scheduler deve realizar uma série de rotinas especificas do kernel, como o bottom half handlers (que será tratado mais adiante) e deve tratar da gila de esperas de tarefas do scheduler. Seleção de processo: o scheduler deve escolher o processo que irá rodar. A prioridade é o meio pelo qual ele escolhe. Troca de processos: o scheduler salva as condições que o processo atual apresenta (contexto específico do processo) e carrega o contexto do novo processo que irá rodar. Em ambientes multiprocesados (SMP - Simultaneous Multi Processing), cada processador tem um scheduler para tratar separadamente quais processos irão rodar nele. Dessa forma, cada processo guarda informação sobre o processador atual e o último processador em que rodou. Processos que já tenham rodado em um processador tem preferência em relação aqueles que não tenham rodado ali ainda. Essa implementação permite um ligeiro acréscimo de ganho no desempenho do sistema. Políticas de Escalonamento Existem critérios para o escalonamento dos processos em Linux: Policy: Pode haver duas políticas de escalonamento round-robin e first-in-first-out (FIFO). Priority: A prioridade do processo é dada de acordo com o tempo que ele gastou para executar (em jiffies). Jiffies é uma variável que indica a quantidade de tempo que um processo pode ser executado, onde cada valor atribuído depende de cada máquina. Quanto maior o tempo em uma execução anterior, menor a prioridade do processo. Real time priority: Esse recurso é usado para processo de tempo real. Através disso, os processos de tempo real podem ter prioridade relativa dentro desse conjunto. A prioridade pode ser alterada através de chamadas do sistema. Counter: É a quantidade de tempo (em jiffies) que os processos têm permissão para rodar. É setada a prioridade quando o processo é rodado pela primeira vez e decrementada a cada tick do clock. Sistemas de Arquivos Visão Geral sobre Sistema de Arquivos 17 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Conceitualmente, arquivos são mecanismos de abstração que fornecem uma forma de armazenar e recuperar informações em disco. A características mais importante de qualquer mecanismo abstração é a forma de identificar os objetos como os quais o mecanismo trata. Quando um processo cria um arquivo, é preciso que tal arquivo receba um nome, normalmente dado pelo processo. Quando tal processo termina sua execução, o arquivo continua a existir, podendo ser acessado por outros processos, usando para tanto o nome atribuído ao arquivo. O sistema de arquivos é a parte mais visível do sistema operacional. A maioria dos programas lêem e escrevem em pelo menos um arquivo. O sistema de arquivos encara o disco como se este fosse composto simplesmente por uma seqüência de blocos de tamanho fixo. Cada bloco pode ser composto por 1, 2, 4 ou mais setores físicos; desta forma, tamanhos possíveis de blocos (ou clusters) são 512 bytes, 1 KB, 2KB e assim por diante. Sistema de Arquivos Unificado O Sistema de Arquivos Unificado está presente em todas as variantes Unix.Ao contrário da grande maioria dos sistemas operacionais, unidades de armazenamento distintas são enxergadas como parte de um único e imenso diretório, de forma que quando estamos acessando um arquivo, por exemplo, no diretório /etc podemos estar acessando uma unidade de disco rígido enquanto o arquivo que estamos lendo na outra janela pode estar num CD-ROM. Conceitos Fundamentais O Linux organiza o seu sistema de arquivos em uma árvore hierarquizada, resultando em uma estrutura única que agrega todas as informações relativas ao sistema de arquivos. Cada nodo da árvore pode representar um arquivo, um dispositivo de entrada e saída, ou ainda um diretório. O Linux faz distinção entre nome maiúsculos e minúsculos. Normalmente um nome de arquivo é composto de nome e uma extensão, separada por ponto no Linux, o tamanho da extensão, se houver, fica a critério do usuário, e um arquivo pode até ter duas ou mais extensões. Ex : prog.c.Z. Não há limite de números de caracteres utilizados para dar nome a arquivos. O Sistema Operacional Linux, olha o arquivo como uma sequência de byte, sem nenhuma estrutura, isto dá uma flexibilidade espantosa ao sistema de arquivo. Os programas de usuários, podem colocar o que desejarem nos arquivos e identificá-los da forma que lhe for mais conveniente, o Unix não influência em nada nesta processo de identificação. Tipos de arquivos O Linux suporta arquivos regulares, arquivos de diretório, arquivos especiais de caracteres e arquivos especiais blocados. Os arquivos regulares são aqueles que contém informações de usuários, por exemplos, tipo ASCII. Arquivos diretórios são arquivos usado na manutenção do sistema de arquivo. Arquivos especiais de caracteres estão diretamente ligado à entrada/saída e são usados para dispositivos seriais de entrada/saída, tais como terminais, impressoras e rede. Os arquivos especiais blocados são usado modelar dispositivos. Diretórios Para tratar dos arquivos, o sistema operacional normalmente lança mão do diretórios, no caso do Linux diretórios hierárquico. Os diretórios são um tipo de arquivo. No Linux todos os arquivos fazem parte de um diretório, assim eles são mantidos e organizados, os diretórios são meios de oferecer endereços dos arquivos, de maneira que o SO possa acessá-los rapidamente e facilmente, ao 18 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS entra pela primeira vez em sua conta, o usuário já esta em um subdiretório denominado subdiretório de entrada. Conta É uma senha que é aberta pelo administrador do sistema (denominado de root) onde o usuário indentifica-se para o computador, que então dá acesso ao seu diretório de entrada, onde você pode executar os comandos permitidos a sua senha. Nos SO padrão Unix, a conta é obrigatória para todos. Arquivos Compartilhados Quando vários usuários estão trabalhando juntos em um projeto, ele comumente precisam compartilhar arquivos. Em decorrência disto, muitas vezes é conveniente que um arquivo compartilhado apareça simultaneamente em diretórios diferentes que pertençam a diferentes usuários. A conecção entre um diretório e um arquivo compartilhado é chamada de ligação (link). O próprio sistema de arquivo é um gráfico acíclico dirigido , ou DAG, em vez de árvore. No Linux os blocos do disco não são listados no diretório, mas numa estrutura de dados associada ao próprio arquivo. Esta estrutura é chamada nó-i, é a forma como o Linux implementa compartilhamento arquivo. Sistema de Arquivos no Linux - Descrição O Sistema de Arquivos do Linux é estrutura de organização de arquivos em formato de árvore, que permite: · hierarquia (de diretórios e arquivos); · proteção das informações; · compartilhamento dos arquivos. Todos os arquivos linux estão arranjados em uma única árvore hierárquica. Em linux o usuário não precisa se preocupar com discos específicos como C:, D:, etc. Na verdade, o usuário não necessita saber como os arquivos estão arranjados fisicamente em um ou mais discos. O Linux suporta diversos sistemas de arquivos. Estes não são acessados via identificadores, e sim combinados numa estrutura hierárquica em árvore, que representa o sistema de arquivos como uma entidade única. Cada partição do disco pode conter um sistema de arquivos. Dentre esses sistemas destacamos: Minix: mais antigo e presumivelmente o mais confiável, mas bastante limitado em características (algumas datas não aparecem , máximo de 30 caracteres para nome de arquivos, etc...) e restrito em armazenamento (no máximo 64 Mb por sistema de arquivos). Xia: ma versão modificada do sistema de arquivos minix, o qual aumenta os limite de nomes de arquivos e de sistemas de arquivos, mas não introduz novas facilidades. Não é muito popular, mas comenta-se que funcione muito bem. ext2: mais poderoso e popular sistema de arquivos nativo do Linux. Desenhado para ser facilmente compatível com os avanços das novas versões, sem a necessidade de criar novamente os sistemas de arquivos já existentes. Ext: Uma versão antiga do ext2 que não é mais compatível com versões atuais. É raro vê-la instalada em sistemas novos e mesmo os mais antigos têm sido convertidos para ext2. Adicionalmente há o suporte a diversos outros sistemas de arquivos, para simplificar a troca de informações com outros sistemas operacionais. Estes sistemas de arquivos funcionam como se fossem nativos, exceto pela perda de algumas facilidades presentes no UNIX, ou apresentam algumas particularidades. Msdos: Compatibilidade com MS-DOS (e OS/2 e Windows NT) através de sistemas de arquivos FAT/FAT32. 19 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Umsdos: Sistemas de arquivos MS-DOS estendidos para suportar nomes longos, donos, permissões, links e arquivos de dispositivos do Linux. Isso permite que um sistema de arquivos msdos possa ser usado como se fosse um sistema Linux, removendo a necessidade de uma partição distinta para o Linux. iso9660: O sistema de arquivos padrão do CD-ROM. A extensão Rock Ridge que permite nomes longos também é suportada automaticamente. Nfs: Sistemas de arquivos em redes que permitem o compartilhamento e o fácil acesso aos arquivos entre diversos computadores da rede. Hpfs: O sistema de arquivos do OS/2. Sysv: Sistema de arquivos do System V/386, Coherent e Xenix. Sistema de Arquivos Linux É criado durante a ―formatação‖ da partição de disco Após a formatação toda a estrutura para leitura/gravação de arquivos e diretórios pelo sistema operacional estará pronta para ser usada. Normalmente este passo é feito durante a instalação de sua distribuição GNU/Linux. Cada sistema de arquivos tem uma característica em particular mas seu propósito é o mesmo: Oferecer ao sistema operacional a estrutura necessária para ler/gravar os arquivos/diretórios. Entre os sistemas de arquivos existentes posso citar: • Ext2 - Usado em partições Linux Nativas para o armazenamento de arquivos. • Ext3 - Este sistema de arquivos possui melhorias em relação ao ext2, como destaque o recurso de jornaling. Ele é totalmente compatível com o ext2 em estrutura. O journal mantém um log de todas as operações no sistema de arquivos, caso aconteça uma queda de energia elétrica (ou qualquer outra anormalidade que interrompa o funcionamento do sistema), o fsck verifica o sistema de arquivos no ponto em que estava quando houve a interrupção, evitando a demora para checar todo um sistema de arquivos (que pode levar minutos em sistemas de arquivos muito grandes). • Swap - Usado em partições Linux Swap para oferecer memória virtual ao sistema. Sistema de Arquivos Second Extended File System (ext2) Atualmente, o sistema de arquivos mais utilizado pelo Linux é o EXT2 (Second Extended File System). Nele os arquivos são guardados em blocos de mesmo tamanho, determinado durante a criação do sistema de arquivos. A partição lógica que ele ocupa é dividida em Block Groups, cada um contendo informações críticas para a integridade do sistema de arquivos, além de conter arquivos e diretórios. Cada Block Group contém um superblock, que contém informações sobre o sistema de arquivos. Normalmente, só o superblock do primeiro Block Group é lido. Os demais são utilizados caso haja corrupção do sistema de arquivos. Um arquivo qualquer no Linux é composto por uma quantidade inteira de blocos. Assim, cada arquivo tem seu tamanho arredondado de forma a ocupar um número inteiro de blocos. Por exemplo, se considerarmos blocos de tamanho de 1024 byes, um arquivo de 1025 bytes ocupará dois blocos, ou seja, 2048 bytes. Essa política de alocação implica que se desperdice metade do tamanho de um bloco por arquivo. Esse desperdício é, na verdade, resultante de um compromisso entre desempenho e economia de espaço em disco. A organização de blocos da partição em grupos de blocos também está relacionado com um problema de desempenho, tendo como principal objetivo evitar a disperção de arquivos no disco. Dessa forma, o núcleo tenta alocar para um arquivo os blocos pentencentes a um mesmo grupo, reduzindo os movimentos de seek no momento de acess a esse arquivo. Cada grupo é composto por seis elementos distintos: superbloco, descritor do grupo, bitmap de i-nodos, tabela de i-nodos, e 20 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS bloco de dados. A estrutura básica de construção de arquivos ext2 é o i-nodo: cada arquivo ou diretório no sistema de arquivo ext2 é descrito por um único i-nodo. Cada grupo de blocos possui um bitmap de i-nodos e uma tabela que contém ponteiros para i-nodos de cada arquivo, ou diretório, pertencente ao grupo. Um i-nodo descreve quais blocos compões um arquivo e também armazena uma série de informações relativas a esse arquivo. Todos os i-nodos de uma partição ext2 têm o mesmo tamanho (128 bytes). Modo: esse campo armazena informações relacionadas com os direitos de acesso ao objeto que o i-nodo referencia. Informações: fornece os direitos de acesso, leitura e escrita, associando o arquivo a um usuário e/ou a um grupo de usuários. Tamanho: o tamanho do arquivo em bytes, ou seja, o tamanho real do arquivo e não a quantidade de blocos que ele ocupa. Timestamps: data(hora, dia, mês, ano) em que o i-nodo foi criado ou modificado. Apontadores para blocos: valores que indicam quais blocos compõem o arquivo. Esses apontadores são empregados em 4 níveis: apontadores diretos (12), apontador de indireção simples(1), apontador de dupla indireção(1), e apontador de tripla indireção(1). Nas versões atuais do Linux, o tamanho máximo de um arquivo é limitado a 2 Gigabytes o que não explora toda a capacidade de endereçamento fornecida pela tripla indireção. Partição EXT3 (Linux Native) O sistema de arquivos ext3 faz parte da nova geração extended file system do Linux, sendo que seu maior benefício é o suporte a journaling. O uso deste sistema de arquivos comparado ao ext2, na maioria dos casos, melhora o desempenho do sistema de arquivos através da gravação seqüencial dos dados na área de metadados e acesso mhash a sua árvore de diretórios. A estrutura da partição ext3 é semelhante a ext2, o journaling é feito em um arquivo chamado .journal que fica oculto pelo código ext3 na partição (desta forma ele não poderá ser apagado, comprometendo o funcionamento do sistema). A estrutura idêntica da partição ext3 com a ext2 torna mais fácil a manutenção do sistema, já que todas as ferramentas para recuperação ext2 funcionarão sem problemas. I/O no Sistema de Arquivos do Linux Um dos objetivos de um sistema operacional é ―esconder‖ dos usuários as peculiaridades de um determinado hardware. A gerência de I/O realiza um papel análogo, ou seja, fornece uma interface uniforme para acesso a um determinado dispositivo independente de sua tecnologia. Um exemplo bastante comum são os discos rígidos. Nós encontramos discos IDE, EIDE, SCSI, entre outros, os quais possuem geometria, funcionalidades e capacidades diferentes. Entretando, eles são ―vistos‖ de forma genérica como discos rígidos. Esse é o objetivo da gerência da entrada e saída: criar uma camada de software que esconda, através de uma interface comum, os detalhes específicos de cada dispositivo. O processador não é o único dispositivo ―inteligente‖ de um hardware. Cada dispositivo físico de entrada e saída possui um controlador. Um controlador nada mais é que um processador projetado para realizar uma determinada função específica. Assim, teclado, mouse e portas seriais são normalmente vinculados a um controlador serial; discos IDE, a um controlador IDE; discos SCSI, a um controlador SCSI; interface de rede, a controladores de redes; etc. Cada controlador possui um conjunto próprio de registradores de controle e estado(CSR- Control and Status Registers) 21 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS os quais diferem de controlador para controlador. Os CSR são utilizados para inicializar, encerrar, diagnosticar e realizar operações em um controlador, ou seja, em um dispositivo. Ao invés de cada aplicação codificar a seqüência de comandos CSR, esses estão concentrados no núcleo do sistema operacional já que, por exemplo, ler e escrever são operações comuns a todas as aplicações. O software que implementa, no núcleo do sistema operacional, essas operações é conhecido como driver de dispositivos (device drivers). Segurança O Sistema Operacional Linux é o segundo sistema operacional mais seguro do mundo. Seu pai, o Unix, é o único que o supera. Este é um dos motivos mais favoráveis a sua utilização, principalmente em servidores. Outro fato que comprova esta segurança é que, das invasões realizadas com sucesso, apenas 1% está relacionado com Linux como alvo. Ainda, esta invasão a ele ocorre por dois motivos: falha humana (99,5% dos casos) e falha do sistema(0,5% dos casos). Porém segurança não é apenas relacionada à invasão mas também a vírus, trojans, worms e todos aqueles softwares mal intencionados. A cada 1000 pragas virtuais lançadas 1 é para Linux. O mais incrível é que qualquer falha ou praga é eliminada em questão de pouquíssimas horas devido ao grande número de programadores que o Linux possui. Diferente dos demais sistemas operacionais, o Linux fecha todas as portas por padrão, ou seja, mantém abertas somente as que realmente precisam estar. São justamente estas portas abertas que devem ser filtradas (protegidas) sem as fechar utilizando um Firewall (portão, muro, parede de fogo). Ele tem a função de liberar ou não o acesso as requisições feitas por endereços da internet (IPs), através de regras definidas pelo administrador do sistema. Não existe um padrão de regras que venham juntamente com o pacote padrão de instalação, se não for especificado o Sistema Operacional não vai filtrar. Outro ponto interessante de ressaltar é que todas configurações de firewall realizadas no Linux ou em qualquer outro sistema operacional devem ser tanto para meios externos (internet) quanto meios internos (intranet), nem mesmo os usuários internos estão livres da maldade. O Linux utiliza como firewall o iptables, que também pode ser chamado de ipchains ou ipfwadm depende da versão do kernel (núcleo do sistema) como mostra o quadro abaixo: Versão do Kernel Sistema Utilizado 2.0.x Ipfwadm 2.2.x Ipchains 2.4.x ou superior Iptables Segurança interna SAMBA - Compartilhamento de arquivos Apesar de praticamente não existir pragas para Linux, eles existem em massa para o sistema operacional da Microsoft. Isto representa perigo se você estiver em uma rede com estações de trabalho windows, por conseqüência utiliza-se o samba para liberar acesso a arquivos no servidor linux. Este compartilhamento criado entre o servidor e estação pode permitir que um vírus ou trojan apague os arquivos lá encontrados, isto requer que você possua um bom antivírus instalado em cada estação e mantenha-o bem atualizado. Porém não basta apenas isso, mas deve-se tomar as seguintes precauções. . Não utilizar login único para toda a rede (mesmo que seja uma rede pequena). . Cada login deve ter acesso restrito somente ao que realmente precisa. . Contas de usuários visitantes devem ser evitadas, e se existirem deve ter o acesso mais 22 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS restrito possível. . Não permitir que o usuários alterem as permissões de arquivo. . Não criar a conta root ou administrador. . Não compartilhar jamais a raiz do sistema (parece obvio mais já algumas pessoas o fazerem). SQUID – Acesso à Internet O squid é proxy(distribuidor) de internet, tem a função de liberar e controlar o acesso a internet em uma rede. Para que ele seja um aliado e ajudante no dia-a-dia é necessário bloquear além de sites e portas, as extensões executáveis e de arquivos compactados. Também devem se restringir o horário de acesso à Internet. CUIDADOS ESPECIAIS Senha e usuário root O ideal é que apenas que uma pessoa saiba esta senha. O usuário root não deve ser usado no cotidiano, apenas na instalação e manutenção dos serviços e usuários do servidor. SSH - Acesso remoto Este serviço permite o acesso à linha de comando do linux de qualquer outro local. Porém ao habilitar este serviço não deve-se liberar acesso ao usuário root. Telnet Protocolo e serviço muito conhecido nos ambientes Windows. Não é recomendado o uso, em hipótese alguma, no Linux, pois sua segurança já foi posta em cheque inúmeras vezes. Windows 2003 A arquitetura do Windows 2003 é fortemente inspirada no princípio de micronúcleo, pois cada funcionalidade do sistema é oferecida e gerenciada por um único componente do sistema operacional. Todavia, módulos fora do micronúcleo executam operações em modo protegido (modo kernel), por isso, não é puramente micronúcleo. O Windows 2003 também segue uma organização em camadas, e explora o modelo orientado a objetos. Foi projetado de modo a permitir a execução de aplicações escritas para outros sistemas operacionais. A estrutura pode ser dividida em duas partes: modo usuário (onde estão localizados os sistemas protegidos) e o modo kernel (o executivo). O executivo constitui o núcleo do Windows 2003, exportando funções para serem utilizadas no modo usuário e funções que só são acessíveis por componentes (módulos) pertencentes ao próprio núcleo. Os principais componentes do executivo são: • Gerência de objetos; • Gerência de processos; • Gerencia de memória virtual; • Monitor de segurança; • Módulo de suporte; • Gerência de E/S. O núcleo do Windows 2003 foi projetado de forma a dar suporte ao multiprocessamento simétrico quando executado em máquinas multiprocessadas. O multiprocessamento assimétrico na presença de n processadores, um processador é pré-selecionado e dedicado a execução do sistema operacional, 23 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS deixando para os processos de usuários os n-1 processadores restantes. Já o multiprocessamento simétrico, o sistema operacional pode ser executado em qualquer processador que esteja livre, ou ainda em todos os processadores simultaneamente, explorando melhor o potencial dos vários processadores existentes. Gerência de Memória O Windows 2003 implementa um sistema de memória virtual baseado em um espaço de endereçamento linear (plano) de 32 bits, o que oferece até 4 Gbytes de memória virtual. Esse espaço de endereçamento é normalmente dividido em duas partes de igual tamanho (2 Gbytes): uma destinada ao processo usuário (parte inferior) e outra destinada ao sistema operacional (parte superior). Em outros termos, uma aplicação (processo usuário) possui, no máximo, um tamanho de 2 Gbytes. Na realidade, o Windows 2003 oferece a opção de modificar essa alocação inicial de forma a atribuir 3 Gbytes ao processo usuário e 1 Gbyte ao sistema operacional. Essa possibilidade permite que certas aplicações, como, por exemplo, banco de dados, armazenem uma grande parcela de dados dentro do espaço de endereçamento da própria aplicação (processo). O Windows 2003 prevê ainda uma extensão, denominada de VLM (Very Large Memory) – destinada aos processadores de arquitetura de 64 bits – que permite a um processo usuário alocar até 28 Gbytes de memória virtual suplementar. A alocação de memória por um processo Windows é realizada em duas fases. Inicialmente, o processo reserva um certo número de páginas da memória virtual sem necessariamente utilizá-la. Em seguida, à medida que o processo necessita de memória, essas páginas pré-alocadas são mapeadas a áreas efetivas de armazenamento no disco (área de swap). Essa segunda fase é conhecida, em terminologia Windows, como commit. Dessa forma, as páginas relativas ao espaço de endereçamento total de um processo usuário (2 Gbytes) podem estar em um de três estados: livres, reservadas ou dedicadas (commited). As páginas livres são as páginas do espaço de endereçamento não utilizadas pelo processo. As páginas reservadas correspondem àquelas pré-alocadas mas ainda não mapeadas a uma área de armazenamento real. Uma vez esse mapeamento efetuado, as páginas pré-alocadas tornam-se páginas dedicadas. A distinção entre páginas reservadas e páginas dedicadas é justificada pela redução do tamanho do arquivo de paginação (swap) necessário a um processo. Apenas as páginas dedicadas consomem área de armazenamento. Por questões de desempenho, o Windows 2003 permite também que um processo, possuindo os privilégios necessários, bloqueie páginas em memória, fazendo com que essas páginas nunca sofram procedimento de swapping. Como a concepção do Windows é toda orientada a objetos, a memória alocada por um processo é representada através de um objeto memória. Dois processos podem compartilhar um mesmo espaço de endereçamento referenciando um objeto comum. Para o caso de compartilhamento de apenas uma região de memória o Windows oferece a abstração de visão (view). Essa abstração consiste em um processo mapear uma porção de seu espaço de endereçamento a um objeto (section object) o qual é utilizado por outros processos para acessos compartilhados a essa região. O mecanismo de view é bastante flexível. Ele permite que, em caso de swapping de uma região compartilhada de memória, as páginas correspondentes a essa região sejam transferidas ou para a área de swap ou para um arquivo especial (mapped file). È possível ainda fixar um endereço virtual para essa região compartilhada, permitindo assim que ela resida sempre em um mesmo endereço (virtual) em todos os processos que a utiliza. Finalmente, a área de view pode ter diferentes tipos de acesso, como por exemplo, apenas leitura, leitura e escrita, execução e outros. 24 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Sistema de Arquivos O Windows 2003 possui um sistema de arquivos próprio, O NTFS (NT File System), projetado de forma a oferecer segurança de acesso, garantia da consistência de dados em presença de falhas e suporte a discos de grande capacidade. O Windows oferece ainda suporte a outros sistemas de arquivos como o FAT (MS-DOS e Windows 3,1), FAT32 (Windows 95, 98, Millenium), o HPFS (Os/2), além de formatos para cdrom (CDFS) e UDF (Universal Disk Format) para acesso a dados armazenados em DVDs. O grande diferencial do NTFS em relação aos seus predecessores da linha Microsoft está em cobrir as necessidades de alguns pontos considerados como críticos para aplicações em ambientes corporativos, a saber: - Facilidade de recuperação de dados e tolerância a falhas: para alcançar a confiabilidade, que e requisito as aplicações corporativas, uma das técnicas utilizada pelo Windows 2003 é o processamento de transações. Uma transação é definida como uma operação de E/S que altera os dados do sistema de arquivo, ou a estrutura de diretório do volume, de forma indivisível, isto é, cada alteração no sistema de arquivo só é considerada efetivada se for completamente realizada. O NTFS emprega esse modelo de transações para implementar seu recurso de recuperação do sistema de arquivos permitindo que este seja reconstruído, ou, ao menos, mantido em um estado consistente, após uma falha no sistema. - Segurança: O NTFS explora o modelo de objetos para oferecer segurança aos arquivos. Um arquivo aberto é implementado como um objeto arquivo o qual atua como um descritor, definindo os diferentes privilégios de acesso e requisitos de segurança a este. - Suporte a grandes discos e arquivos: o NTFS é projetado para suportar de forma eficiente acesso, manipulação e armazenamento em discos de grandes capacidades. - Fluxos de dados múltiplos: um arquivo e seus atributos são vistos como uma seqüência de bytes, denominada fluxo de dados. Dessa forma, no NTFS, um único arquivo pode ter associado vários fluxos de dados. Essa organização oferece uma grande flexibilidade pois permite que o fluxo de dados que compõe o arquivo seja interpretado de acordo com o fluxo de dados de seu atributo. - Facilidade de indexação: o NTFS permite que arquivos sejam acessados de forma indexada através de atributos (chaves de pesquisa) criados para cada arquivo. - Suporte para sistema POSIX: o NTFS implementa os recursos exigidos pelo POSIX como diferenciação de maiúsculas para nomes de arquivos e diretórios e atalhos (soft links). O NTFS é organizado sobre três estruturas básicas: setor, cluster e volume. O setor, normalmente composto de 512 bytes, é a menor unidade de alocação física do disco. Setores contíguos podem ser organizados em grupos, formando os clusters. Um cluster constitui então a unidade básica de alocação do NTFS, isto é, um arquivo ocupa em disco sempre um número de bytes múltiplo do tamanho do cluster. Um volume corresponde a uma partição lógica do disco. Um volume é composto por uma série de clusters e possui de forma autocontida informações relacionadas a esse disco lógico, isto é, estrutura de diretório, cluster livres e ocupados, etc. Atualmente, o número máximo de clusters permitido a um arquivo no NTFS é 2³², sendo o tamanho máximo de um cluster limitado a 64 Kbytes. Um volume (disco lógico ou partição) é organizado em 4 regiões. A primeira região de um volume NTFS corresponde ao setor de boot, que na realidade pode ocupar até 16 setores físico do disco, apesar do nome ―setor boot‖. O setor de boot possui informações sobre o layout do volume, a estrutura do sistema de arquivos e o programa de boot do Windows. Essa região é seguida pela 25 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Máster File Table (MTF) a qual contém as informações sobre todos os arquivos e diretórios (folders) desse volume, assim como sobre o espaço livre. O MTF é organizado na forma de um conjunto de registros de tamanho variável, em que cada arquivo ou diretório possui um registro associado. Nesses registros, está incluído o próprio MTF, já que ele também não deixa de ser um tipo de arquivo. Cada registro do MTF mantém informações relacionadas ao atributo do arquivo (leitura, escrita, etc.), datas de criação e modificação, nome do arquivo, descritor de segurança. A terceira região é a dos arquivos de sistema, tipicamente de 1 Mbyte, em que são armazenados: uma cópia parcial da MFT (informações suficientes para recuperar erros físicos acontecidos na NFT); um arquivo de logs, referente ao controle de transações do NTFS; um bit map que fornece a ocupação dos clusters do volume; e uma tabela de atributos que define o tipo de acesso e esse volume (sequencial, indexado, etc). Finalmente, a quarta e última região corresponde à área disponível para os arquivos. Como mencionado anteriormente, um dos principais objetivos do NTFS é facilitar a recuperação em caso de falhas. A capacidade de recuperação do NTFS é essencialmente baseada em logs de transação. Uma operação que altere o sistema de arquivos é tratada como uma transação, a qual é gravada na região de logs associada a cada volume. Apenas após a gravação da transação é que a operação é efetivada. È importante salientar que a capacidade de recuperação do NTFS foi projetada para garantir a coerência e a recuperação de estruturas e dados do sistema operacional e não dados de arquivos de usuário. Dessa forma, um usuário jamais perderá o acesso a um volume (partição) em decorrência de uma falha física, ou do sistema, embora possa perder acesso ao conteúdo de um arquivo seu. Entretanto, para suprir a necessidade de recuperação total, o Windows disponibiliza uma série de ferramentas para a tolerância a falhas. Windows XP A denominação XP vem da palavra exPerience. O Windows XP foi idealizado com o objetivo de unificar, em torno de um único produto, seu mercado corporativo com seu mercado de usuários domésticos. Na realidade, essa unificação é feita através de duas versões do Windows XP: o Windows XP Personal Edition, destinado ao mercado doméstico, que substitui o Windows 95, 98, Millenium, NT (versão workstation); e o Windows XP Professional Edition, voltado ao mercado corporativo que substitui o NT nas suas versões server. As principais novidades introduzidas pelo Windows XP estão relacionadas com mecanismos de proteção ao sistema de arquivos e conectividade à Internet. Sob o ponto de vista de proteção do sistema de arquivo, o Windows XP impede que arquivos antigos substituam versões mais recentes. No caso de drivers de dispositivos, é possível restaurar a versão anterior na eventualidade da instalação de um driver mais recente apresentar problemas. O suporte à proteção, na presença de múltiplos usuários, foi estendida em relação aos mecanismos oferecidos pelo Windows 98 e pelo Windows Millenium embutidos em seu próprio núcleo. Em relação à conectividade em rede, quando conectado à Internet, o Windows XP oferece ao usuário algumas funcionalidades típicas de firewall embutidas em seu próprio núcleo. Além disso, uma série de ferramentas buscando simplificar o uso do Windows por usuários leigos forma introduzidas, como por exemplo, gravação de cdrom diretamente a partir do Windows Explorer, emprego de temas para tela de fundo, atualizações automáticas, mecanismos para publicação de arquivos de imagens e de texto na Internet, entre outros. Entre as novidades do Windows XP, está ainda um mecanismo de proteção como pirataria denominada de WPA (Windows Product Activation). Seu funcionamento á baseado na criação de um código único, válido apenas para o computador no qual o Windows XP é instalado. Esse código é 26 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS criado no momento da instalação e é obtido através de identificadores próprios únicos a cada computador, tais como número de série da BIOS, do disco rígido, o endereço físico da placa de rede (endereço MAC), etc. Esse código é então informado à Microsoft, que imediatamente gera e reenvia um código de liberação para o uso do Windows XP. Ambos os códigos, o gerado na instalação e o código de instalação, são cadastrados na Microsoft. Sempre que houver uma modificação de hardware da máquina, ou a tentativa de burlar o sistema de ativação do Windows XP, o usuário deverá repetir o procedimento de ativação do Windows XP ou seja, recontactar a Microsoft e gerar uma nova chave de ativação. Esse procedimento criou, na comunidade de usuários, muita controvérsia devido a rumores de que a Microsoft aproveitava-se dele para obter informações adicionais sobre a configuração da máquina, como por exemplo, os softwares instalados. Essa polêmica levou à análise das transações realizadas, pelo mecanismo WPA por consultores independentes que concluíram que apenas o código de ativação é enviado à Microsoft. O Windows XP foi desenvolvido com a preocupação de manter a compatibilidade com várias aplicações já existentes para a família Windows, principalmente jogos e multimídia. A Microsoft divulgou que todos os aplicativos existentes para Windows 98, Millenium e Windows NT continuarão a funcionar normalmente no Windows XP. A mesma preocupação de compatibilidade existe a nível de hardware, assim sendo, o Windows XP dispõe de uma grande gama de drivers para os mais diversos periféricos. Além disso, é possível instalar em uma máquina Windows XP drivers existentes para outras versões da família Windows. As diferenças entre as versões Windows XP Personal Edition e Windows XP Professional Edition estão relacionados com desempenho e atividades de gerenciamento. A versão Professional explora o multiprocessamento real oferecido pelas máquinas multiprocessadoras, ao passo que a versão Personal é otimizada para máquinas monoprocessadoras. Sob o ponto de vista do Sistema Operacional, o Windows XP é um Sistema Operacional de 32 bits e herda em muito a arquitetura NT 5.0. As modificações, segundo a Microsoft, estão em otimizações de algoritmos básicos e nas estruturas de dados internas ao núcleo. Essas melhorias fazem com que o Windows XP apresente um desempenho melhor que seus antecessores. O Windows XP, assim como o Windows 2000 (NT 5.0), não fornece a capacidade de realizar boot em modo DOS. A compatibilidade com aplicativos que rodam sob DOS (como o Clipper) é feita exatamente da mesma forma que no Windows 2000, ou seja, através de um emulador DOS. Mac OS X Mac OS X (lê-se Mac OS dez, e não Mac OS xis) é um sistema operacional proprietário, desenvolvido, fabricado e vendido pela empresa americana Apple, destinado aos computadores da linha Macintosh e que combina a experiência adquirida com a tradicional GUI desenvolvida para as versões anteriores do Mac OS com um estável e comprovado kernel. A última versão do Mac OS X possui certificação UNIX. Assim, o Mac OS X, lançado inicialmente pela Apple Computer em 2001, é uma combinação do Darwin (um kernel derivado do microkernel Mach) com uma renovada GUI chamada Aqua. As primeiras versões do Mach (não-microkernel) foram derivadas do BSD. 27 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Descrição O Mac OS X apresenta uma grande mudança em relação aos sistemas operacionais anteriores do Macintosh e o código que é a base do sistema é completamente diferente do de versões anteriores. Apesar da maioria das alterações estarem nos "bastidores" do sistema operacional, a interface gráfica de usuário Aqua é o novo recurso mais visível. O uso de bordas arredondadas, cores translúcidas e outros adereços trouxe mais cores e texturas às janelas e controles do Desktop do que a interface Platinum do OS 9. Inicialmente isso gerou bastante controvérsia entre os usuários, com uns alegando que a interface tinha ficado "como um brinquedo" e com falta de profissionalismo; outros alegando que era "outra grande inovação da Apple". O visual é instantaneamente reconhecível e antes mesmo do lançamento da primeira versão do Mac OS X, outros desenvolvedores começaram a produzir skins para aplicativos personalizáveis como o Winamp para ficarem mais parecidos com o visual Aqua. A Apple ameaçou processar pessoas que fazem ou distribuem programas que oferecem uma interface que eles dizem ser derivada de seu design patenteado. O núcleo do Mac OS X é um sistema operacional certificado Unix, construído em torno de um kernel XNU com recursos básicos Unix acessáveis através de uma interface de linha de comando. Pouco antes do lançamento do Mac OS X a Apple lançou esse núcleo como Darwin. Baseando-se nesse núcleo, a Apple projetou e desenvolveu um número de componentes de código fechado (closed source) de licença proprietária, incluindo a interface Aqua e o Finder (o sistema de gerenciamento de arquivos). A combinação da interface amigável e o poder do núcleo open source Darwin/BSD tornaram o Mac OS X o ambiente Unix mais bem vendido até hoje em número de computadores vendidos. 28 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Versões Mac OS X v10.0 "Cheetah" Mac OS X v10.1 "Puma" Mac OS X v10.2 "Jaguar" Mac OS X v10.3 "Panther" Mac OS X v10.4 "Tiger" Mac OS X v10.5 "Leopard" Mac OS X v10.6 "Snow Leopard" Sistema de Arquivos O HFS+ também é conhecido como sistema de arquivos Mac OS X Extended, e supera o formato HFS em vários quesitos: pode trabalhar com endereços de bloco de arquivos de até 32bits, contra 29 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS 16bits do sistema anterior; aceita nomes de arquivos com até 255 caracteres, em vez de apenas 31; tem formato de nome de arquivo Unicode, em vez do já antiquado MacRoman; e entre outros, o que mais gosto, que é a possibilidade de lidar com arquivos de até 8EB (Exabytes)! Para se ter uma idéia, um Exabyte dá mil Petabytes, um milhão de Terabytes, ou um bilhão de Gigabytes. Acredito que os editores de vídeo não teriam problemas para gravar seus clipes com esse formato… Apesar disso, existe uma pequena diferença entre ―poder‖ e ―ser‖. O formato NTFS que existe nos Windows NT, XP, 2003 e Vista, por exemplo, alcança o dobro esse valor como máximo tamanho de um único arquivo. Por outro lado, a implementação real só permite um limite de quase 16TB, ou aproximadamente 16.000GB. Isso dá um banho de água do Oceano Ártico nos antigos FAT16 e HFS. O limite de tamanho de arquivos para estes é de 2GB. Podemos ver em que formato se encontra qualquer disco conectado a um Mac através do atalho de teclas Command-I sobre o mesmo. No caso do nosso querido sistema X, a opção de formato HFS+ já existe há algum tempo, então é provável que apareça a designação Mac OS X Extended no local onde indica o respectivo formato. Além disso, ainda há outros termos. Por exemplo, quando vamos formatar um disco com o Disk Utility, vemos as seguintes opções: Mac OS Extended (Journaled): de acordo com a Apple, o formato journaled foi apresentado no OS X 10.2.2 Server, e sua função é aumentar a segurança quanto ao armazenamento de dados, no que diz respeito a evitar falhas de integridade em casos extremos. Um disco com essa característica mantém registro de todas as suas atividades, e em caso de instabilidade ou travamento do sistema, esse registro — um journal, que pode ser entendido como ―relatório‖ — é usado para restaurar o estado do sistema ao que tenha sido gravado, depois do reinicio do sistema. Conceito muito parecido ao rollback em Banco de Dados. Mac OS Extended: é possível ter um disco HFS+ sem a opção de journaling. Também se pode desabilitar essa função, através de comandos via Terminal, para quem precise ganhar desempenho em computadores mais lentos. O risco de perda de dados aqui é maior que na opção anterior. Mac OS Extended (Case-sensitive, Journaled): combinação da primeira opção, respeitando as diferenças entre maiúsculas e minúsculas. Algo parecido com o que acontece no UNIX. Mac OS Extended (Case-sensitive): igual ao anterior, só que sem journaling. MS-DOS (FAT): seria o FAT32, da Microsoft. Formatar um disco com essa especificação garante compatibilidade integral entre quaisquer sistemas operacionais, porém há a limitação de tamanho de arquivos a 4GB, o que pode ser um problema para editores de vídeo e outras pessoas que trabalhem com arquivos de tamanho grande. Também um problema para quem lida com imagens de DVD-DL, já que o dual-layer consiste exatamente em levar o tamanho de um DVD normal a quase 8,5GB. Tirando a opção MS-DOS (FAT), todas as outras são algum tipo de HFS+, e ainda havia uma opção UFS (UNIX File System), para quem quisesse, por alguma razão, usar o formato do sistema UNIX. O journaling é sempre aconselhado, por aumentar a segurança na manipulação de dados, e diminuir o risco de perdas em caso de que o computador pare de funcionar, trave ou fique sem energia elétrica, por falta de luz, por exemplo. Hoje em dia, para quem precise trabalhar com arquivos muito grandes, eu recomendaria o uso do formato HFS+ Journaled para qualquer disco, mesmo que ele seja utilizado depois em computadores com Windows. Existe um programa muito bom da MediaFour, chamado MacDrive, que é pago, mas 30 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS pela função que tem, até sai barato. Permite ver e trabalhar com qualquer disco, dentro do Windows, com formatos HFS e HFS+, em todas as variações. Isso garante a possibilidade de abrir arquivos maiores que 4GB de tamanho nos sistemas operacionais da Microsoft e da Apple, sem qualquer problema. Há que lembrar sempre que, de modo nativo, o Mac OS X não consegue permitir acesso completo a arquivos em discos com formato NTFS, usado nos Windows 2000, XP e Vista. Creio que também há soluções para isso, apesar de que eu não conheço nenhuma de fácil uso e que funcione de modo parecido ao MacDrive. Talvez algum dia HFS+ e NTFS se comuniquem, como já acontece com o formato da Apple e o FAT32. O Sistema Operacional UNIX Dada sua larga aceitação, o sistema operacional UNIX será utilizado como referência neste curso. O sistema é dividido em duas partes: programas e serviços: shell, mail, vi, date, etc; núcleo(kernel): Provê suporte aos programas e serviços. Desenvolvido nos Laboratórios da Bell em meados da década de setenta, o sistema UNIX inicialmente atendia as necessidades específicas do grupo de Ciência da Computação da Bell. A razão da aceitação do UNIX é explicada pelos atributos abaixo: escrito em linguagem de alto nível, o que facilita seu transporte para diferentes plataformas; interface simples para com o usuário(shell); fornece primitivas que permitem o desenvolvimento de programas complexos a partir de programas mais simples; estrutura hierárquica de arquivos; formatação de arquivos baseada no conceito de stream (cadeia) de bytes; interfaceamento simples e consistente com os dispositivos periféricos; multiusuário/multiprogramado; esconde a arquitetura do hardware, permitindo que um programa execute em múltiplas plataformas. Uma Visão Geral do Sistema Operacional UNIX Programas interagem com o núcleo através da evocação de um conjunto bem definido de chamadas de sistema. Muitos destes programas são denominados com andos. O conjunto de chamadas do sistema e os algoritmos internos que implementam estas chamadas formam o corpo do núcleo. A organização do ambiente UNIX pode ser vista na forma de camadas conforme mostrado na figura 1.1. Sistema de Arquivos O sistema de arquivos do UNIX é caracterizado por: estrutura hierárquica; tratamento consistente dos dados de arquivo; facilidade na criação/eliminação de arquivos; crescimento dinâmico de arquivos; proteção aos dados dos arquivos; tratamento dos dispositivos periféricos como arquivos de dados. O sistema de arquivo é organizado na forma de árvore. Os programas no ambiente UNIX não possuem nenhum conhecimento sobre o formato interno no 31 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS qual o núcleo armazena os dados de arquivo. Os dados são fornecidos pelo UNIX como um stream (cadeia) de bytes, cabendo aos programas interpretarem o seu conteúdo. Este tratamento estende-se também aos diretórios, ou seja, estes são vistos como arquivos regulares. O acesso aos arquivos é controlado pelas permissões de acesso associadas a cada arquivo. No caso, temos os seguintes tipos de permissões: leitura, escr ita e execução, para os seguintes tipos de usuários: proprietário do arquivo, grupo de usuários ou qualquer outro usuário. Uma característica importante do UNIX é o fato de que os programas acessam os dispositivos periféricos com a mesma sintaxe utilizada para o acesso aos arquivos regulares. Os dispositivos também são protegidos da mesma forma que os arquivos regulares. Ambiente de Processamento Um programa é um arquivo executável, e um processo é uma instância do programa em execução. No UNIX vários processos podem executar simultaneamente, sendo que várias instâncias de um mesmo programa podem existir ao mesmo tempo no sistema. CONCLUSÃO Através do assunto descrito neste trabalho, pode-se verificar que os sistemas operacionais Linux e Windows, seja ele da versão 2003 ao XP, são sistemas operacionais que atendem a maioria dos requisitos fundamentais para suprir as necessidade de diferentes classes de usuários que possuam ou não um alto grau de conhecimento em informática. Cada Sistema Operacional estudado possui características um pouco diferentes em relação ao gerenciamento de memória, escalonamento, sistemas de arquivos e segurança. No Windows percebemos alguma semelhança entre suas versões, algumas melhoradas ou adaptadas para a próxima versão que seria lançada, mas em geral, todos os Sistemas Operacionais criados seguiram uma linha de desenvolvimento que favoreça o usuário, que na verdade é o maior beneficiário dessa tecnologia. Licenças GNU General Public License A GNU General Public License (Licença Pública Geral), GNU GPL ou simplesmente GPL, é a designação da licença para software livre idealizada por Richard Stallman no final da década de 1980, no âmbito do projecto GNU da Free Software Foundation (FSF). A GPL é a licença com maior utilização por parte de projectos de software livre, em grande parte devido à sua adoção para o Linux. O software utilizado para administrar o conteúdo da Wikipédia é coberto por esta licença, na sua versão 2.0 ou superiores. Em termos gerais, a GPL baseia-se em 4 liberdades: 1. A liberdade de executar o programa, para qualquer propósito (liberdade nº 0) 2. A liberdade de estudar como o programa funciona e adaptá-lo para as suas necessidades (liberdade nº 1). O acesso ao código-fonte é um pré-requisito para esta liberdade. 3. A liberdade de redistribuir cópias de modo que você possa ajudar ao seu próximo (liberdade nº 2). 4. A liberdade de aperfeiçoar o programa, e liberar os seus aperfeiçoamentos, de modo que toda a comunidade se beneficie deles (liberdade nº 3). O acesso ao código-fonte é um pré-requisito para esta liberdade. 32 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Com a garantia destas liberdades, a GPL permite que os programas sejam distribuídos e reaproveitados, mantendo, porém, os direitos do autor por forma a não permitir que essa informação seja usada de uma maneira que limite as liberdades originais. A licença não permite, por exemplo, que o código seja apoderado por outra pessoa, ou que sejam impostos sobre ele restrições que impeçam que seja distribuído da mesma maneira que foi adquirido. A GPL está redigida em inglês e actualmente nenhuma tradução é aceita como válida pela Free Software Foundation, com o argumento[1] de que há o risco de introdução de erros de tradução que poderiam deturpar o sentido da licença. Deste modo, qualquer tradução da GPL é não-oficial e meramente informativa, mantendo-se a obrigatoriedade de distribuir o texto oficial em inglês com os programas. A licença GPL foi originalmente publicada em Janeiro de 1989. No entanto, passado pouco tempo, ficou claro que o texto da licença comportava vários problemas, pelo que em Junho de 1991 foi publicada a GPL versão 2, sendo ao mesmo tempo introduzida uma nova licença LGPL. Em 2005, Stallman anunciou que estava a preparar uma nova versão da licença em conjunto com Eben Moglen. Essa nova versão, foi chamada de GPLv3 e o primeiro esboço foi publicado em 16 de Janeiro de 2006, sendo a versão final lançada em 29 de Junho de 2007. Licença Comercial O termo Licença Comercial é normalmente associado a contratos de licenciamento de uso de software. Os softwares chamados comerciais são aqueles pelos quais o usuário paga uma taxa de licenciamento para poder utilizar. É importante observar que, de acordo com o modelo de licenciamento de software comercial, o que o usuário adquire quando paga pelo software é o direito de utilizá-lo segundo as regras definidas por seu contrato de licenciamento de uso. Uma analogia pode ser feita com livros: quando se compra um livro está se adquirindo a mídia impressa, mas o direito autoral do conteúdo é do autor ou da editora. As duas restrições mais comuns nas licenças comerciais são: O direito de redistribuição, por exemplo, realizar uma cópia dele e repassá-la para outro usuário. A cópia de softwares em desacordo com sua licença comercial é considerada uma cópia ilegal e esta prática é conhecida pelo termo pirataria. O direito de alterar o funcionamento do software, adaptando-o para um fim específico.Como o software comercial raramente é distribuído com seu código fonte, para alterá-lo seria necessário utilizar a prática da engenharia reversa, o que costuma ser terminantemente proibido por esse tipo de licença. A Licença Comercial define também, em muitos casos, os serviços que a empresa que vende o software disponibiliza para os usuários que adquirem seu direito de uso, tais como suporte, correção de erros de funcionamento, atualização periódica e acesso a documentação de uso e outros materiais - normalmente via Internet. As contrapartidas dos softwares cujo uso é regido por licenças comerciais são os chamados freeware, cuja licença de utilização é gratuita, e os softwares livres, normalmente distribuídos com código fonte e que possuem uma licença de uso que permite explicitamente a sua cópia, modificação e redistribuição. 33 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Licença de software livre Software Livre é uma expressão formalizada pela primeira vez[1] por Richard Stallman, na sequência do início do Projecto GNU[2], e seguidamente da Free Software Foundation como braço legal do Projecto. Todo e qualquer programa de computador cuja licença de direito de autor conceda ao utilizados as seguintes 4 liberdades... 1. A liberdade de executar o programa, para qualquer propósito (liberdade no. 0) 2. A liberdade de estudar como o programa funciona, e adaptá-lo para as suas necessidades (liberdade no. 1). Acesso ao código-fonte é um pré-requisito para esta liberdade. 3. A liberdade de redistribuir cópias de modo que você possa ajudar ao seu próximo (liberdade no. 2). 4. A liberdade de aperfeiçoar o programa, e liberar os seus aperfeiçoamentos, de modo que toda a comunidade se beneficie (liberdade no. 3). Acesso ao código-fonte é um pré-requisito para esta liberdade. ... diz-se ser um Software Livre. A realização de tais ações é reservada, pelo conceito de direito de autor, aos detentores dos direitos, que necessitam assim de permitir de forma explícita estas liberdades recorrendo a uma Licença de Software Livre. As licenças de Software Livre também se popularizaram, por darem a garantia jurídica aos utilizadores de que não estão cometendo actos de infracção de direito de autor ao copiar ou modificar o software. A remoção de qualquer uma destas quatro liberdades descaracterizaria sua condição de Software Livre. Há vários tipos de licenças de Software Livre[3], a diferença entre elas está sobretudo na forma, Copyleft, weak-Copyleft ou non-Copyleft. As mais populares licenças de Software Livre são a Licença GPL e a Licença BSD, originalmente criada na Universidade de Berkeley. Tipos de Sistemas Operacionais Sistemas Monoprogramáveis/Monotarefa *Processador, memória e periféricos exclusivamente à execução de um único programa. *Relacionados ao surgimento dos Mainframes. *Simples implementação *Pouca preocupação com proteção. Sistemas Multiprogramáveis/Multitarefa *Vieram substituir os monoprogramáveis. *Mais complexos e eficientes. *SO gerência acesso concorrente dos recursos(memória, processador e periféricos) enter os diversos programas. *Aumento da produtividade *Redução dos custos. 34 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Sistemas Batch *Programas armazenados em discos ou fita onde esperam para ser executados seqüencialmente. *Programas(jobs) não exigem interação com os usuários. *Ex. Compilações, Linkedições, sorts, backups . Sistemas de Tempo Compartilhados (Time-Sharing) *Permitem interação com usuários *Conhecidos como sistemas on-line. *Para cada usuário o SO aloca uma fatia de tempo(Time-Slice) do processador. *Implementação complexa. *Aumentam a produtividade e reduz custos. *Preempção Capacidade de um SO tem de interromper um processo em execução. *PreempçãoQuantum *PreempçãoPrioridade Sistemas Tempo Real *Tempos de resposta dentro de limites rígidos. *Não existe idéia de fatia de tempo. *Processador ocupado o tempo que for necessário por um programa até que outro prioritário apareça.(prioridade controlada pelo programa e não pelo SO.) *Presentes em monitoramento de refinarias de petróleo, trafego aéreo ,Usinas termoeléctricas e nucleares tempo de resposta é fundamental. Sistemas com Múltiplos Processadores *Duas ou mais UCPs interligadas, trabalhando em conjunto. *Um fator chave e a forma de compartilhamento da memória e dispositivos I/O e a comunicação entre as UCPs. ºSist. fortemente acoplados. Duas ou mais UCPs e um único S.O. voltado para solução de um único problema. ºSist. fracamente acoplados.Dopis ou mais sistemas de computação(multicomputadores), conectados aravés de linhas de comunicação. *EscalabilidadeCapacidade computacional em menor custo. *ReconfiguraçãoCapacidade do S.O. cdontinuar o processo mesmo que um dos processadores falhe ou pare de funcionar. Sistemas Fortemente Acoplados *Varios processadores compartilhando uma única memória e gerenciados por apenas um S.O. *Varios programas ao mesmo tempo ou um programa dividido em subprogramas para execuçaão simultanea em mais de um processador. *Usado em : desenvolvimento aeroespacial, prospecção de petroleo, simulações, processamento de imagens, CAD [ aplicações que façam uso intensivo da UCP. Sistemas Assimétricos *Um processador primario que controla os secundarios e pela execução do S.O. *Se o processador mestre falhar, todo o sistema ficará incapaz de continuar. Sistemas Simétricos *Todos os processadores têm as mesmas funções, podendo executar o SO independentemente. 35 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS *Quando um processador falha, o sistema continua funcionando, porém com menor capacidade de computação. Multiprocessamento Processamento Vetorial *Permite a manipulação de vetores internos. *só é vantajoso quando as aplicações executadas têm um elevado grau de código vetorizável, como problemas numéricos, processamento de imagens, estudos meteorológicos e de física nuclear. Que realizam repetidas operações aritméticas de ponto flutuante em grandes vetores. Processamento Paralelo *Por mais de um processador ao mesmo tempo. *Paralelismo explícito indicado pelo próprio programador através de comando de linguagem utilizada, onde ele determina as sub-rotinas que podem ser executadas em paralelo. *paralelismo implícito determinado pelo próprio sistema, provável obter programas mais eficientes e confiáveis. Pouco utilizada devido à dificuldade de programação. Organização Funcional *Interliving Múltiplos acessos simultâneos a memória. Barramento comum *Forma mais simples de comunicação entre múltiplos processadores e outras unidades funcionais.[comom bus ou time-shared bus]. *O maior problema dessa organização e que somente uma unidade funcional pode estar utilizando o barramento em um determinado instante. No caso de ocorrer algum problema no barramento, todo sistema ficará comprometido. *Arquitetura simples, econômica e flexível limitados a poucos processadores. BARRAMENTO COMUM UCP Memória Memória UCP Processamento de E/S Processamento de E/S Memória UCP Processamento de E/S Barramento cruzado *Evita o problema de gargalo *Crossbar-switch matrix. *Comunicação simultânea entre diferentes unidades funcionais. *Número de processadores que podem ser adicionados ao sistema e ilimitado. *O preço de seu alto desempenho está no custo e complexidade do sistema. 36 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS BARRAMENTO CRUZADO Memória Memória Memória UCP Processamento de E/S UCP Processamento de E/S UCP Processamento de E/S Memória Multiport *Acessos simultâneos a um mesmo modulo de memória realizados através de múltiplas portas, existentes em cada módulo de memória. MEMÓRIA MULTIPORT UCP Memória Processamento de E/S UCP Memória UCP Memória Processamento de E/S Memória Processamento de E/S Sistemas Fracamente Acoplados *Dois ou mais sistemas de computação interligados, cada sistema com seu próprio SO. *Rede de computadores existem dois ou mais sistemas independentes, também chamados de nós, host ou estações, com capacidade de processamento própria e interligados através de linhas de comunicação. 37 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS SISTEMAS FRACAMENTE ACOPLADO Rede Sistemas Operacionais de Rede (SOR) *Cada Nó possui seu próprio SO *Permite: Cópia remota de arquivos Emulação de Terminal Impressão remota Gerência remota Correio eletrônico *Cada nó é independente do outro, podendo inclusive ter SO diferentes. *Caso a conexão entre os nós sofra qualquer problema, os sistemas podem continuar operando normalmente, apesar de alguns recursos se tornarem indisponíveis. *Melhor exemplo é Local Area Network-LAN. SISTEMAS OPERACIONAIS DE REDE 38 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Sistemas Operacionais Distribuídos Rede usuário *Relacionamento mais forte entre seus componentes, onde geralmente os SOs são os mesmos. *Balanceamento de cargas. *Processador mais livre é escolhido *Compartilhamento de impressoras, discos e fitas, independentemente do sistema em que a aplicação estejaCluster. CLUSTER Comp. 1 Comp. 2 *Uma grande vantagem e a capacidade de redundância do sistema, caso aconteça algum problema com um dos componentes , um deles tome o papel do sistema defeituoso. *Em aplicações de missão critica, como controlo de tráfego aéreo, existem sistemas especialmente desenvolvidos para essa finalidadeSistemas de tolerância a falhas (Fault tolerance). *Padrões de alguns fabricantes Distributed Computing Environment DCE, Common Object Request Broker Architecture COBRA, Object Linking and Embedding OLE. 39 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Organização Funcional ORGANIZAÇÃO BARRAMENTO *Sistemas conectados a uma única linha de comunicação e todos compartilham o mesmo meio, geralmente em redes locais, caso haja algum problema com o meio de transmissão, todos os nós da rede ficarão incomunicáveis. ORGANIZAÇÃO DE BARRAMENTO Organização Distribuída *Caminhos alternativos entre os diversos nós da rede. Caso apresente problema, linhas alternativas permitirão que a rede continue funcionando. Redes Distribuídas. ORGANIZAÇÃO DISTRIBUÍDA 40 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Histórico dos Sistemas Operacionais Antes da década de 50, os computadores eram muito difíceis de serem programados. Era necessário conhecer totalmente sua arquitetura, e tal operação era efetuada em painéis com cerca de 6.000 conectores, em linguagem de máquina. Nesta fase os computadores não possuíam ainda dispositivos para interagir com o usuário, como teclados e monitores. Na década de 50, já com a utilização de transistores, sucedeu-se um grande avanço tecnológico, melhorando a velocidade dos processadores e a capacidade dos meios de armazenamento, em especial a memória e os discos magnéticos. Por volta de 1953 foi introduzido o primeiro sistema operacional, um programa de controle que permitia uma interação, mesmo que limitada, entre o operador e a máquina, otimizando a execução das tarefas. Em 1959 foi criada uma versão de sistema operacional que já implementava conceitos de memória virtual, conceito este largamente utilizado nos sistemas atuais. Na década de 60, a partir do surgimento dos circuitos integrados, foi possível difundir u uso de sistemas computacionais em empresas, com diminuição de custos e tamanho dos equipamentos. Além disso, esta década presenciou inúmeras inovações na área de sistemas operacionais, presentes até hoje, como os ambientes de multitarefa, multiprogramação, multiprocessamento e time-sharing, tendo o desenvolvimento destas técnicas avançado até o meado da década de 70, onde também foram implementadas as tecnologias baseadas em arquitetura VLSI (chips), as primeiras redes de computadores, e o desenvolvimento de diversas linguagens de programação de alto nível. A década de 80 foi marcada pela criação dos microcomputadores, baseados em microprocessadores de uso pessoal. Liderados pela IBM, diversos fabricantes seguiram por essa linha, porém alguns deles não abandonando a fabricação dos computadores de grande porte, como foi o caso da própria IBM. Nota-se que, a partir do meado da década de 80, acontece uma divisão de águas, com a indústria passando a produzir equipamentos de grande porte e muitos modelos de microcomputadores, que também precisavam de sistemas operacionais bastante evoluídos. Foram, então, utilizadas as técnicas modernas já existentes nos ambientes de grande porte na implementação de sistemas operacionais para os microcomputadores, com versões diversas, todas inicialmente monousuário/monotarefa (devido à baixa capacidade de armazenamento dos micros, naquela época). Com o avanço da tecnologia, os micros ganharam discos rígidos e outros periféricos, possibilitando a criação de sistemas operacionais mais evoluídos nesta categoria de computadores, quando surgiram os sistemas monousuário/multitarefa, que executam até hoje. Cronologia Grande porte (mainframes) 1990 1950 1960 1º Sistema Operacional Monoprogramável Monotarefa Sistemas Multitarefa 1970 1980 Sistemas Multiprogramáveis Multitarefa Introduzido o conceito de Memória Virtual 41 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Tipos de Sistemas Operacionais Tipos de Sistemas Operacionais Sistemas Monoprogramáveis/ Monotarefa Sistemas Multiprogramáveis/ Multitarefa Sistemas Com Múltiplos Processadores Sistemas Monoprogramáveis/Monotarefa Os primeiros sistemas operacionais eram voltados tipicamente para a execução de um único programa. Qualquer outra aplicação, para ser executada, deveria aguardar o término do programa corrente. Neste tipo de sistema, o processador, a memória e os periféricos permanecem exclusivamente dedicados à execução de um único programa. Os sistemas monoprogramáveis estão diretamente ligados ao surgimento, na década de 50/60, dos primeiros computadores. Embora os sistemas operacionais já tivessem evoluído com as tecnologias de multitarefa e multiprogramáveis, os sistemas monoprogramáveis voltaram a ser utilizados na plataforma de microcomputadores pessoais e estações de trabalho devido à baixa capacidade de armazenamento destas máquinas, na época. Era muito clara a desvantagem deste tipo de sistema, no que diz respeito à limitação de tarefas (uma de cada vez), o que provocava um grande desperdício de recursos de hardware. _______ _______ _______ _______ _______ CPU Memória Principal Dispositivos E/S Programa/Tarefa Comparados a outros sistemas, os monoprogramáveis são de simples implementação, não existindo muita preocupação com problemas decorrentes do compartilhamento de recursos como memória, processador e dispositivos de E/S. Sistemas Multiprogramáveis/Multitarefa Constituindo-se uma evolução dos sistemas monoprogramáveis, neste tipo de sistema os recursos computacionais são compartilhados entre os diversos usuários e aplicações: enquanto um programa 42 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS espera por um evento, outros programas podem estar processando neste mesmo intervalo de tempo. Neste caso, podemos observar o compartilhamento da memória e do processador. O sistema operacional se incumbe de gerenciar o acesso concorrente aos seus diversos recursos, como processador, memória e periféricos, de forma ordenada e protegida, entre os diversos programas. As vantagens do uso deste tipo de sistema são a redução do tempo de resposta das aplicações, além dos custos reduzidos devido ao compartilhamento dos recursos do sistema entre as diferentes aplicações. Apesar de mais eficientes que os monoprogramáveis, os sistemas multiprogramáveis são de implementação muito mais complexa. _______ _______ _______ _______ _______ _______ _______ _______ _______ _______ CPU Programa/Tarefa _______ _______ _______ _______ _______ Programa/Tarefa Memória Principal Programa/Tarefa Dispositivos E/S _______ _______ _______ _______ _______ Programa/Tarefa Sistemas Multiprogramáveis *SO Conjunto de rotinas que executam concorrentemente de uma forma ordenada. *SO Multiprogramáveis surgiram para resolver a baixa utilização de recursos do sistema. *A utilização concorrente da UCP deve ser implementada de maneira que, quando um programa perde o uso do processador e depois retorna para continuar o processamento, seu estado deve ser idêntico ao do momento em que foi interrompido. *A eficiência de um sistema multiprogramável resulta em maior complexidade do SO. 43 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Interrupção e Exceção *Interrupção e gerada pelo SO ou por algum dispositivo(Hardware). Mecanismo de Interrupção Salva os Registradores Interrupção Programa . . . . . . . . Identifica a origem da interrupção Obtém o endereço da rotina de tratamento Rotina de tratamento Restaura os registradores *Vetor de Interrupção Contem a relação de todas as rotinas de tratamento existentes, associadas a cada tipo de interrupção. *Interrupção mascaráveis podem ser desabilitada pelo processador. *Interrupção não mascaráveis não podem ser desabilitadas pelo processador. *Exceção é resultado direto da execução de uma instrução do próprio programa. *Controlador de pedidos de interrupção IRQ(Dispositivo dos hardware)Avalia as interrupções geradas e suas prioridades de atendimento. *O mecanismo de tratamento de exceções é semelhante ao de interrupções, porém, muitas vezes, podem ser escritas pelo próprio programador. *A diferença fundamental entre exceção e interrupção é que a primeira é gerada por evento síncrono, enquanto a segunda por eventos assíncronos. *Síncronoé resultado direto da execução do programa corrente, previsíveis, só podem ocorrer um de cada vez. *Assíncronoocorre independentemente da execução do programa corrente, imprevisíveis, podem ocorre múltiplas vezes simultaneamente. 44 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Operações de Entrada/Saída *Permite que a UCP agir de maneira independente dos dispositivos de E/S. Controlador ou Interface UCP Memória Principal Contr olado r *1ª maneira básica de controle do UCP sobre as operações E/SUCP sincroniza com o periférico para início da transferência de dados, fica testando para saber quando a operação termina E/S controlada por programa... mantinha a UCP ocupada até o final da operação(Busy wait). *2ª maneira básica de controle do UCP sobre as operações E/S Após o início da transferência de dados a UCP fica livre para realizar outras tarefas. Em determinados intervalos de tempo o SO deve realizar teste para saber do andamento da operação(polling). *Mecanismo de interrupção no hardware O próprio controlador interrompe a UCP para aviso do término da operação de E/S (E/S controlada por interrupção). Controlador Recebe sinal de leitura Armazena em memória ou registradores próprios (através de uma linha de controle) Sinaliza interrupção ao processador UCP Atende a interrupção (rotina responsável pelo tratamento desse tipo de interrupção) Transfere os dados para a memória principal. UCP Controlador Retorna a execução do programa Disponível para outra operação interrompido. *DMA (Direct Memory Access)- Técnica de transferência de dados por parte do controlador que controla momentaneamente o barramentoPermite que um bloco de dados seja transferido entre a memória e periféricos, sem a intervenção da UCP, exceto no início e final da transferência. *Bufferárea de memória reservada exclusivamente para este propósito. *A extensão do conceito do DMA possibilitou o surgimento dos Canais de E/S introduzidos pela IBM no sistema 7094 45 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS *Canais de E/S Processador capaz de executar programas de E/S, permitindo o controle total sobre operações de E/S. As instruções de E/S são armazenadas na memória principal pela UCP, pórem o canal é responsável pala sua execução. Atua como elo entre o UCP eo controlador. CANAL DE E/S Memória Principal UCP Canal de E/S Controlador Controlador *Processador de E/SPossui memória própria, eliminando a necessidade dos programas de E/S serem carregados para a memória principal, assim usando o minimo de intervenção da UCP. Buffering *Utilização de uma área de memória para transferência de dados entre os periféricos e a memória principal denominada buffer. *A unidade de transferência é o registro . Operações usando o Buffer Memória principal UCP Gravação Buffer Leitura Gravação Controlador de E/S Leitura 46 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Estágios da técnica de Buffering Dado transferido para o buffer após uma operação de leitura, liberando o dispositivo de entrada para nova leitura. UCP manipula o dado localizado no buffer, enquanto o dispositivo de entrada faz nova leitura. Spooling (Simultaneous peripheral operation on-line) *Introduzida no final dos anos 50. *Foi a base dos sistemas Batch. *Basicamente utiliza o disco como um grande Buffer, permitindo que dados sejam lidos e gravados em disco, enquanto outros jobs são processados. *Exemplo: Comando de impressão executado por um programa Informações que serão impressas são gravadas em um arquivo em disco(arquivo spool). Impressão. Técnica de Spooling Programa Arquivo de Spool S.O. Impressão Reentrância *Capacidade de um código de programa(código reentrânte) poder ser compartilhado por vários usuários, exigindo que apenas uma cópia do programa esteja na memória. *Não pode ser modificado por nenhum usuário no momento em que esta sendo executado. *Ex.: editores de texto, compiladores, linkers. *Grande economia de memória, aumento da performance do sistema. Proteção do Sistema *Modos de AcessosMecanismos de proteção. Gerência de Memória Erro de violação de acesso programa tenta acessar posição de memória fora de sua área, e o programa é encerrado. Esquema de LockDois usuários acessando mesmo arquivo. TimerLoops infinitos. Compartilhamento de dispositivos de E/S pelo S. O.Nenhum outro programa deve interferir quando um programa usa a impressora até que libere. Sistema Multiprogramável/Multitarefa Os sistemas multiprogramáveis/multitarefa podem ser classificados de acordo com a forma com que suas aplicações são gerenciadas, podendo ser divididos em sistemas batch, de tempo compartilhado e de tempo real, de acordo com a figura abaixo. 47 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Sistemas Multiprogramáveis/ Multitarefa Sistemas BATCH Sistemas de Tempo Compartilhado Sistemas de Tempo Real Sistemas BATCH Foram os primeiros sistemas multiprogramáveis a serem implementados na década de 60. Nesta modalidade, os programas eram submetidos para execução através de cartões perfurados e armazenados em disco ou fita, para posterior execução. Vem daí o nome batch (lote de cartões). O processamento em batch tem como característica não exigir interação do usuário com o sistema ou com a aplicação. Todas as entradas ou saídas são implementadas por meio de algum tipo de memória secundária, geralmente disco ou fita. Aplicações deste tipo eram utilizadas em cálculo numérico, compilações, back-ups, etc. Estes sistemas, se bem projetados, podem ser bastante eficientes devido à melhor utilização do processador, mas podem oferecer tempos de resposta bastante longos. Atualmente, os sistemas operacionais simulam este tipo de processamento, não havendo sistemas dedicados a este tipo de execução. Sistemas de Tempo Compartilhado Também chamados sistemas de time-sharing, permitem que diversos programas sejam executados a partir da divisão de tempo do processador em pequenos intervalos, denominados fatia de tempo (ou time-slice). Caso a fatia de tempo não seja suficiente para a conclusão do programa, este é interrompido pelo sistema operacional e substituído no processador por outro, enquanto aguarda nova fatia de tempo. Neste tipo de processamento, cada usuário tem a impressão de que a máquina está dedicada ao seu programa, como se ele fosse o único usuário a se utilizar do sistema. Geralmente permitem interação do usuário com a aplicação através de terminais compostos por monitor, teclado e mouse. Estes sistemas possuem uma linguagem de controle que permite ao usuário interagir com o sistema operacional através de comandos. Assim, é possível verificar arquivos armazenados em disco ou cancelar execução de programas. Normalmente, o sistema responde em apenas alguns segundos à maioria destes comandos, o que se levou a chamá-los também de sistemas on-line. A maioria das aplicações comerciais atualmente é processada em ambiente de tempo compartilhado, que oferece tempos baixos de respostas a seus usuários e menores custos, em função do alto grau de compartilhamento dos diversos recursos do sistema. Sistemas de Tempo Real Este tipo de sistema é implementado de forma bastante semelhante ao de tempo compartilhado. O que caracteriza a diferença entre eles é o tempo exigido no processamento das aplicações. Enquanto nos sistemas de tempo compartilhado o tempo de processamento pode variar sem comprometer as aplicações em execução, nos sistemas de tempo real os tempos de execução devem estar dentro de limites rígidos, que devem ser obedecidos, caso contrário poderão ocorrer problemas irreparáveis. 48 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS No sistema de tempo real não existe a idéia de fatia de tempo como nos sistemas de tempo compartilhado. Um programa ocupa o processador o tempo que for necessário ou até que apareça um outro com um nível de prioridade maior. Esta prioridade de execução é definida pela própria aplicação e não pelo sistema operacional, como nos sistemas de tempo compartilhado. Estes sistemas são utilizados em aplicações de controle de processos, como monitoramento de refinarias de petróleo, controle de tráfego aéreo, de usinas, ou em qualquer aplicação onde o tempo de processamento é fator fundamental. Sistemas com Múltiplos Processadores Os sistemas com múltiplos processadores caracterizam-se por possuir duas ou mais CPUs interligadas e trabalhando em conjunto. A vantagem deste tipo de sistema é permitir que vários programas sejam executados ao mesmo tempo ou que um mesmo programa seja subdividido em várias partes para serem executadas simultaneamente em mais de um processador. Esta técnica permitiu a criação de sistemas computacionais voltados para processamento científico, prospecção de petróleo, simulações, processamento de imagens e CAD. Um fator chave no desenvolvimento dos sistemas multiprocessados é a forma de comunicação entre as CPUs e o grau de compartilhamento da memória e dos dispositivos de E/S. Em função destes fatores, podemos classificar os sistemas multiprocessados de acordo com a figura a seguir: Sistemas com Múltiplos Processadores Sistemas Fortemente Acoplados Simétricos Sistemas Fracamente Acoplados Assimétricos Redes Distribuídos Tipos de Sistemas com Múltiplos Processadores Na figura podemos perceber a divisão dos sistemas multiprocessados em duas categorias iniciais: sistemas fortemente acoplados e fracamente acoplados. A grande diferença entre estas duas categorias é que nos sistemas fortemente acoplados existe apenas uma memória a ser compartilhada pelos processadores do conjunto, enquanto que nos fracamente acoplados cada sistema tem sua própria memória individual. A taxa de transferência entre processadores e memória em sistemas fortemente acoplados é muito maior que nos fracamente acoplados. Nos sistemas fortemente acoplados a memória principal e os dispositivos de E/S são gerenciados por um único sistema operacional. Quando todos os processadores na arquitetura são iguais, diz-se que o sistema é simétrico. No entanto, quando os processadores são diferentes, dá-se à arquitetura a denominação assimétrica. 49 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Nos sistemas fracamente acoplados, como os processadores estão em arquiteturas diferentes, somente interligados por cabos de interconexão, cada CPU constitui uma máquina independente, com memória própria, dispositivos de E/S e sistemas operacionais independentes. Nesta subdivisão, temos como exemplo as redes e os sistemas distribuídos. No ambiente de rede, existem dois ou mais sistemas independentes (hosts), interligados por linhas telefônicas, que oferecem algum tipo de serviço aos demais, permitindo que um host compartilhe seus recursos, como impressora e diretórios, com os outros hosts da rede. Enquanto nos sistemas em rede os usuários têm conhecimento dos hosts e seus serviços, nos sistemas distribuídos os sistema operacional esconde os detalhes dos hosts individuais e passa a tratá-los como um conjunto único, como se fosse um sistema só, fortemente acoplado. Os sistemas distribuídos permitem, por exemplo, que uma aplicação seja dividida em partes e que cada parte seja executada por hosts diferentes na rede. Para os usuários e suas aplicações é como se não existisse a rede, mas um único sistema centralizado. Outros exemplos de sistemas distribuídos são os clusters. Em um cluster podem existir dois ou mais servidores ligados por algum tipo de conexão de alto desempenho, e o usuário não conhece os nomes dos membros do cluster e nem quantos são. Quando é necessário algum serviço, basta solicitar ao cluster para obtê-lo, sem se preocupar com quem vai dispor e oferecer tal serviço. Clusters são muito utilizados em servidores de bancos de dados e Web. Sistemas Multiprogramáveis Um Sistema Operacional pode ser visto como um conjunto de rotinas que executam concorrentemente de forma ordenada. A possibilidade de um processador executar instruções em paralelo com operações de entrada e saída permite que diversas tarefas sejam executadas concorrentemente. É este conceito de concorrência o princípio fundamental para o projeto e implementação de sistemas multiprogramáveis. Os sistemas multiprogramáveis surgiram a partir das limitações dos sistemas monoprogramáveis onde os recursos computacionais como processador, memória e dispositivos de E/S eram utilizados de maneira muito pouco eficiente, limitando seu desempenho, com muitos destes recursos permanecendo ociosos por longos períodos de tempo. Nos sistemas monoprogramáveis somente um programa pode estar em execução de cada vez, permanecendo o processador dedicado exclusivamente a uma tarefa, ficando ocioso enquanto uma operação de leitura em disco é realizada. O tempo de espera é relativamente longo, já que as operações de E/S são muito lentas se comparadas à velocidade de operação do processador. Outro aspecto a ser considerado é a sub-utilização da memória principal, onde um programa nem sempre ocupa todo o espaço disponível, ficando o restante inutilizado. Nos sistemas multiprogramáveis vários programas podem ser alocados na memória, concorrendo pelo uso do processador. Dessa forma, quando um programa solicita uma operação de E/S, outros programas poderão utilizar o processador, deixando a CPU menos ociosa e tornando o uso da memória mais eficiente, pois existem vários residentes e se revezando na utilização do processador. A utilização concorrente da CPU deve ser feita de maneira que, quando um programa perde o uso do processador e depois retorna para continuar sua execução, seu estado deve ser idêntico ao do momento em que foi interrompido. O programa deverá continuar sua execução exatamente na instrução seguinte àquela onde havia parado, aparentando ao usuário que nada aconteceu. Em sistemas de tempo compartilhado existe a impressão de que o computador está inteiramente dedicado ao usuário, ficando esse mecanismo totalmente transparente aos usuários. 50 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Quanto ao uso dos periféricos, é comum nos sistemas monoprogramáveis é comum termos, por exemplo, impressoras paradas por um grande período de tempo e discos com acesso restrito a um único usuário. Esses problemas são minimizados nos sistemas multiprogramáveis, onde é possível compartilhar os dispositivos de E/S, como impressoras e discos, entre diversos usuários e aplicativos. Interrupção e Exceção Durante a execução de um programa, alguns eventos inesperados podem ocorrer, ocasionando um desvio forçado no seu fluxo normal de execução. Esses eventos são conhecidos como interrupção ou exceção, e podem ser resultado de sinalizações de algum dispositivo de hardware externo ao ambiente memória/processador. A diferença entre interrupção e exceção é dada pelo tipo de evento ocorrido, embora alguns autores e fabricantes não façam tal distinção. A interrupção é o mecanismo que permitiu a implementação da concorrência nos computadores, sendo o fundamento básico dos sistemas multiprogramáveis/multitarefa. Uma interrupção é sempre gerada por um evento externo ao programa e, sendo assim, independe da instrução que está sendo executada. Um exemplo de interrupção é quando um dispositivo avisa ao processador que alguma operação de E/S está completa. Neste caso, o processador deve interromper o programa para tratar o término da operação. Ao término de cada instrução a Unidade de Controle (situada dentro do processador) verifica a ocorrência de algum tipo de interrupção. Desta forma, o programa em execução é interrompido e seu controle é desviado para uma rotina do sistema responsável por tratar o evento ocorrido, denominada rotina de tratamento de interrupção. Para que o programa interrompido possa retornar posteriormente à sua execução é necessário que, no momento da interrupção, um certo conjunto de informações sobre sua execução seja preservado. Essas informações consistem basicamente no conteúdo dos registradores internos da CPU, que deverão ser restaurados para a continuação do programa. Programa Salva Contexto Identifica a origem Interrupção Trata a Interrupção Rotina de Restaura Contexto Tratamento Mecanismo de interrupção/exceção Para cada tipo de interrupção existe uma rotina de tratamento associada, para onde o fluxo do programa é desviado. A identificação do tipo de evento ocorrido é fundamental para determinar o endereço da rotina adequada ao tratamento da interrupção. As interrupções podem ser geradas: - Pelo programa do usuário (entrada de dados pela console ou teclado) - Pelo hardware (operações de E/S) 51 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS - Pelo sistema operacional (ao término da fatia de tempo do processador destinada ao programa) As interrupções sempre são tratadas pelo Sistema Operacional. A exceção é um evento semelhante à interrupção, pois também de fato interrompe um programa. A principal diferença é que a exceção é o resultado da execução de uma instrução dentro do próprio programa, como a divisão por zero ou a ocorrência de um overflow (estouro de capacidade de um campo) numa operação aritmética. Na maioria das vezes, a exceção provoca um erro fatal no sistema, causando o término anormal do programa. Isto se deve ao fato de que a exceção é melhor tratada dentro do próprio programa, com instruções escritas pelo programador. Buffer A técnica de buffering consiste nua utilização de uma área em memória principal, denominada buffer, criada e mantida pelo Sistema Operacional, com a finalidade de auxiliar a transferência de dados entre dispositivos de E/S e a memória. O buffer permite minimizar a disparidade de velocidade entre o processador e os dispositivos de E/S, e tem como objetivo principal manter tanto os dispositivos de E/S como o processador ocupados a maior parte do tempo. A unidade de transferência do mecanismo de buffering é o registro. O buffer deve permitir o armazenamento de vários registros, de forma que o processador tenha à sua disposição dados suficientes para processar sem ter que interromper o programa a cada leitura/gravação no dispositivo de E/S. Enquanto o processador está ocupado processando, os dispositivos de E/S estão efetuando operações para outros processos. SPOOL A técnica de spooling foi criada inicialmente para auxiliar a submissão de processos ao sistema, sendo os processos gravados em fita para posterior leitura e execução. Com o aparecimento dos terminais para acesso ao sistema, esta técnica teve sua função adaptada para armazenar o resultado da impressão dos programas em execução. Isto é conseguido através da criação e manutenção, pelo Sistema Operacional de uma grande área em disco, com a finalidade de simular uma impressora. Desta forma, todos os usuários e seus programas imprimem, na verdade, para este arquivo em disco, liberando a associação dos dispositivos de impressão diretamente aos programas que estão executando. O usuário consegue visualizar o resultado de seus programas na tela dos terminais, gerando assim mais eficiência e economia de papel e fita de impressão. À proporção que vão sendo gerados no SPOOL, os relatórios vão sendo liberados para impressão pelo operador do sistema, de forma ordenada e seqüencial. Para cada usuário, é como se ele tivesse uma impressora associada para si. Reentrância É comum, em sistemas multiprogramáveis, vários usuários utilizarem os mesmos aplicativos simultaneamente, como editores de texto, compiladores e outros utilitários. Nesta situação, se cada usuário que utilizasse um destes aplicativos trouxesse o código executável para a memória, haveria então diversas cópias de um mesmo programa ocupando espaço na memória, o que causaria um grande desperdício de espaço. Reentrância é a capacidade de um código executável (código reentrante) ser compartilhado por vários usuários, exigindo apenas uma cópia do programa em memória. A reentrância permite que cada usuário esteja executando um trecho diferente do código reentrante, manipulando dados próprios, exclusivos de cada usuário. 52 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Normalmente códigos reentrantes são utilizados em utilitários do sistema, como editores, compiladores e linkers, promovendo um uso mais eficiente da memória e um desempenho maior do sistema. Alguns sistemas operacionais permitem a possibilidade de se implementar o conceito de reentrância em aplicações desenvolvidas pelo próprio usuário, mas não é comum. Segurança e Proteção do Sistema A eficiência proporcionada por um ambiente multiprogramável implica em maior complexidade do sistema operacional, já que alguns problemas de proteção surgem como decorrência deste tipo de implementação. Considerando-se que diversos usuários estão compartilhando os mesmos recursos, como memória, processador e dispositivos de E/S, faz-se então necessário existir mecanismos de proteção para garantir a confiabilidade e a integridade dos dados e programas dos usuários, além do próprio sistema operacional. Como vários programas ocupam a memória principal simultaneamente, cada usuário possui uma área reservada onde seus programas e dados são armazenados durante o processamento. O sistema operacional deve possuir mecanismos de proteção a essas áreas, de forma a preservar as informações nela contidas. Caso um programa tente acessar uma posição de memória fora de sua área, um erro indicando a violação de acesso deve ocorrer, sendo responsabilidade do sistema operacional o controle eficiente do compartilhamento dos recursos e a sincronização da comunicação, evitando problemas de consistência. Semelhante ao compartilhamento da memória, um disco também armazena arquivos de diferentes usuários. Novamente o sistema operacional deve garantir a integridade e confiabilidade dos dados de cada usuário. Todo o controle da segurança do sistema é implementado pelo sistema operacional, a partir de mecanismos como grupos de usuários, perfis de usuários e direitos de acesso. A proteção começa geralmente no procedimento de login, quando o usuário faz a conexão inicial ao sistema, através de nome do usuário e senha. A partir daí, toda uma estrutura de controle é iniciada, em função da identificação do usuário, no sentido de proteger as áreas alocadas em memória, em disco, e até mesmo o uso do processador. A proteção e segurança do sistema pode ser implementada também a nível do programa do usuário, com a inserção de rotinas específicas dentro do programa para controlar o acesso de usuários ao aplicativo, além de controlar internamente quais telas e funções tal usuário pode acessar. Operações de Entrada e Saída Nos primeiros sistemas computacionais, a comunicação entre o processador e os periféricos era direta, sendo o processador responsável por efetuar as operações de leitura/gravação nos dispositivos. O surgimento do controlador de E/S permitiu ao processador agir de maneira independente dos dispositivos de E/S. Com esse novo elemento, o processador não mais se comunicava diretamente com os periféricos, mas sim via controlador. Passou a existir então três maneiras básicas de se implementar operações de E/S: por programa: o processador sincronizava-se com o periférico e iniciava a transferência de dados, ficando permanentemente testando o estado do periférico para saber quando a operação chegaria ao seu final. O processador ficava ocupado até o término da operação de E/S. por interrupção: evoluindo o processo anterior, após o início da transferência de dados o processador passou a ficar livre para realizar outras tarefas. Assim, em determinados intervalos de 53 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS tempo o sistema operacional deveria testar o estado dos periféricos para saber se a operação de E/S tinha terminado. Este tipo de operação permitiu um certo grau de paralelismo, já que um programa poderia ser processado enquanto uma operação de leitura/gravação em periférico estava sendo efetuada. Isto permitiu a implementação dos primeiros sistemas multiprogramáveis. Memória Principal CPU Controlador Dispositivos de E/S A necessidade de se transmitir cada vez um volume maior de informações trouxe uma evolução significativa nas operações de E/S. Em vez de o processador ser interrompido várias vezes para interrogar os dispositivos para saber do resultado das operações, o que diminuía sua eficiência devido ao excesso de interrupções, foi criado um dispositivo de transferência de dados chamado de DMA – Direct Memory Access. Esta técnica permite que um bloco de dados seja transferido entre a memória e os dispositivos de E/S sem a intervenção do processador, a não ser no início (quando a operação é solicitada) e no final da transferência (quando o processador é notificado sobre o término da operação). Na figura a seguir, podemos ver a implementação do canal de E/S gerenciando vários controladores e, ligados a estes, vários periféricos. 54 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS O canal de E/S funciona então como uma interface entre os controladores e a CPU, como mostra a figura a seguir: Memória Principal CPU Canal de E/S Controlador Controlador Dispositivos de E/S Dispositivos de E/S 55 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Estrutura do Sistema Operacional Estrutura do Sistema USUÁRIO UTILITÁRIOS NÚCLEO DO SISTEMA HARDWARE O sistema operacional é formado por um conjunto de rotinas que oferecem serviços essenciais aos usuários, às suas aplicações, e também ao próprio sistema. A esse conjunto de rotinas dá-se o nome de núcleo do sistema ou kernel. É fundamental não se confundir o núcleo do sistema com aplicações, utilitários ou o interpretador de comandos, que acompanham o sistema operacional. As aplicações são utilizadas pelos usuários de maneira transparente, escondendo todos os detalhes da interação com o sistema. Os utilitários, como os compiladores, editores de texto e interpretadores de comandos permitem aos usuários, desenvolvedores e administradores de sistema uma interação amigável com o sistema. Existe uma grande dificuldade em compreender a estrutura e o funcionamento do sistema operacional, pois ele não é executado como uma aplicação tipicamente seqüencial, com início, meio e fim. Os procedimentos do sistema são executados concorrentemente sem uma ordem específica ou predefinida, com base em eventos dissociados do tempo. Muitos desses eventos estão relacionados ao hardware e a tarefas internas do próprio sistema operacional. Funções do Sistema As principais funções do núcleo encontradas na maioria dos sistemas comerciais são as seguintes: Tratamento de interrupções e exceções: já explicados anteriormente, em detalhes; Criação e eliminação de processos: função responsável por alocar em memória todos os recursos necessários à execução do processo. É esta função que aloca em memória, além do executável, o contexto do processo, o buffer de leitura/gravação (se necessário), além de listas e estruturas de controle utilizadas pelo sistema operacional. Nesta função também são estabelecidos vínculos físicos a arquivos em disco, fitas e outros periféricos que serão usados no processamento. Quando do fim da execução do programa, é esta função que desaloca todos os espaços em memória ocupados pelo processo, liberando-os para futuras alocações a outros processos; 56 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Escalonamento e controle de processos: função responsável por organizar a fila de acesso ao processador. Utiliza parâmetros do sistema e do perfil do usuário para estabelecer a ordem em que os processos permanecerão à espera pela liberação da CPU, para então entrarem em execução; Gerência de memória: função responsável por fornecer à função de criação/eliminação de processos os endereços em memória disponíveis para alocação; Gerência de sistemas de arquivos: responsável pelo gerenciamento dos arquivos, bem como seu compartilhamento pelos diversos usuários, implementando mecanismos de controle da segurança e direitos de acesso às áreas utilizadas pelos usuários nos diversos dispositivos; Gerência de dispositivos de E/S: responsável por gerenciar os dispositivos, prestando auxílio à criação/eliminação de processos e á gerência de sistemas de arquivos no que diz respeito ao endereçamento e associação de arquivos em periféricos; Suporte a redes e teleprocessamento: é esta função que executa todos os serviços de rede, fazendo o empacotamento das mensagens vindas dos terminais para a CPU central e vice-versa, além de controlar e confirmar o envio e recebimento de todas as mensagens que trafegam pela rede; Contabilização de uso do sistema: responsável por contabilizar o uso de todos os recursos do sistema consumidos pelos usuários e suas aplicações. São registrados: tempo de CPU, tempo corrido, quantidade de área alocada em memória, em disco, linhas impressas, páginas de papel, entre outros. Isto se faz necessário para servir de subsídio para análise de performance, estatísticas de gastos com material de consumo e também para definição de custos de processamento.; Auditoria e segurança do sistema: função extremamente importante, pois detecta e registra (num arquivo especial de LOG) todas as ocorrências de erro e violação de direitos de acesso ao sistema, aos arquivos, à memória e a todos os recursos do sistema. O arquivo de LOG é usado pela gerência de sistemas, com o intuito de verificar e aperfeiçoar os mecanismos de segurança e proteção ao sistema. A estrutura do sistema, a maneira como ele é organizado e o inter-relacionamento entre seus diversos componentes pode variar conforme a concepção do projeto do sistema. System Calls Uma grande preocupação no projeto de sistemas operacionais se refere à implementação de mecanismos de proteção ao núcleo do sistema e também o controle de acesso aos serviços oferecidos pelo sistema. Caso uma aplicação que tenha acesso ao núcleo realize alguma operação que altere sua integridade, todo o sistema poderá ficar comprometido e inoperante. As system calls podem ser entendidas como uma porta de entrada para acesso ao núcleo do sistema e aos seus serviços. Sempre que um usuário ou uma aplicação necessita de algum serviço do sistema, é realizada uma chamada a uma de suas rotinas através de uma system call. Através dos parâmetros fornecidos na system call, a solicitação é processada e uma resposta é enviada à aplicação juntamente com um estado de conclusão indicando o sucesso ou não da operação. Para cada serviço disponível existe uma system call associada, e cada sistema operacional possui seu próprio conjunto de chamadas, com nomes, parâmetros e formas de ativação específicos. Isto explica por que uma aplicação desenvolvida utilizando serviços de um determinado sistema operacional não pode ser diretamente portada para um outro sistema. 57 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Aplicação System Call Núcleo do Sistema Operacional Biblioteca Hardware Modos de Acesso Existem certas instruções que não podem ser colocadas diretamente à disposição das aplicações, pois a sua utilização indevida poderia ocasionar sérios problemas à integridade do sistema. Imagine que uma aplicação atualize um arquivo em disco. O programa, por si só, não pode especificar diretamente as instruções que acessam seus dados no disco pois, como o disco é um recurso compartilhado, sua utilização deve ser gerenciada unicamente pelo sistema operacional. Tal procedimento evita que a aplicação possa ter acesso a qualquer área do disco indiscriminadamente, o que poderia comprometer a segurança e a integridade do sistema de arquivos. Assim, fica claro que existem certas instruções que só podem ser executadas pelo sistema operacional ou sob sua supervisão. As instruções que têm o poder de comprometer o sistema são chamadas de instruções privilegiadas, enquanto as instruções que não comprometem o funcionamento do sistema chamam-se instruções não-privilegiadas. Para que uma aplicação possa executar uma instrução privilegiada, é preciso que haja um mecanismo de proteção no processador, chamado modos de acesso. Existem basicamente dois modos de acesso ao processador: modo usuário e modo kernel. Quando o processador trabalha no modo usuário, somente instruções não-privilegiadas podem ser executadas, tendo assim acesso a um número limitado de instruções do processador. Já no modo kernel (ou supervisor), a aplicação pode ter acesso ao conjunto total de instruções do processador. A melhor maneira de controlar o acesso às instruções privilegiadas é permitir que apenas o sistema operacional tenha acesso a elas. Sempre que uma aplicação necessita executar uma instrução privilegiada, a solicitação deve ser feita através de uma system call, que altera o modo de acesso ao processador do modo usuário para o modo kernel. Ao término da execução da rotina do sistema, o modo de acesso retorna para o modo usuário. Arquiteturas: Sistemas monolíticos, em camadas e microkernel Arquitetura monolítica: é caracterizada por possuir seus módulos compilados separadamente mas linkados formando um único e enorme programa executável. Onde os módulos podem interagir livremente. Os primeiros sistemas operacionais foram desenvolvidos com base nesta arquitetura, o que tornava seu desenvolvimento e, principalmente, sua manutenção muito difíceis. Como vantagens desta arquitetura podemos citar a rapidez de execução e simplicidade de implementação. Como desvantagens, a limitação quanto a inovações futuras e a dificuldade de manutenção. 58 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Aplicação Aplicação Modo Usuário Modo Kernel System call Núcleo do Sistema Hardware Arquitetura monolítica Arquitetura em camadas: com o aumento do tamanho do código dos sistemas operacionais, técnicas de programação estruturada e modular foram incorporadas em seu projeto.Na arquitetura em camadas, o sistema é dividido em níveis sobrepostos. Cada camada oferece um conjunto de funções que podem ser utilizadas somente pelas camadas superiores. Neste tipo de implementação as camadas mais internas são mais privilegiadas que as camadas mais externas. A vantagem da estruturação em camadas é o isolamento das funções do sistema, facilitando sua manutenção. Uma desvantagem é o desempenho, comprometido devido às várias mudanças de estado do processador provocado pela mudança de camadas. 59 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS A figura a seguir mostra esta arquitetura. Camada Usuário Camada Supervisor Camada Executivo Kernel Arquitetura em camadas Arquitetura microkernel (cliente x servidor): uma tendência nos sistemas operacionais modernos é tornar o núcleo do sistema o menor e o mais simples possível. Para implementar esta idéia, os serviços do sistema são disponibilizados através de processos, onde cada um é responsável por oferecer um conjunto específico de funções, como gerência de arquivos, gerência de processos, gerência de memória e escalonamento. Sempre que uma aplicação deseja algum serviço, é realizada uma solicitação ao processo responsável. Neste caso, a aplicação que está solicitando o serviço é chamada de cliente, enquanto o processo que responde à solicitação é chamado de servidor. Um cliente, que pode ser uma aplicação do usuário ou um outro componente do sistema operacional, solicita um serviço enviando uma mensagem para o servidor. O servidor responde ao cliente através de uma outra mensagem. A principal função do núcleo é realizar a comunicação, ou seja, a troca de mensagens entre o cliente e o servidor. A utilização deste modelo permite que os servidores operem em modo usuário, não tendo acesso direto a certos componentes do sistema. Apenas o núcleo do sistema, responsável pela comunicação entre clientes e servidores, executa em modo kernel. Como conseqüência, se ocorrer um erro em algum servidor,este poderá parar, mas o sistema não ficará inteiramente comprometido, aumentando assim a sua disponibilidade. Como os servidores se comunicam através de trocas de mensagens, não importa se os clientes e servidores processam em um sistema com um único processador, com vários processadores ou ainda em um ambiente de sistema distribuído. A arquitetura microkernel permite isolar as funções do sistema operacional por diversos servidores pequenos e dedicados a serviços específicos, tornando o núcleo menor, mais fácil de depurar (procurar e solucionar erros) e, com isso, aumentando a sua confiabilidade. Apesar de todas as vantagens deste modelo, sua implementação é muito difícil. A começar pelo desempenho, comprometido devido às várias trocas de modo de acesso a cada troca de mensagens entre cliente e servidor. Outro problema é que certas funções do sistema operacional, como operações de E/S, 60 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS exigem acesso direto ao hardware. Assim, o núcleo do sistema, além de promover a comunicação entre clientes e servidores, passa a incorpora funções críticas do sistema, como escalonamento, tratamento de interrupções e gerência de dispositivos. Servidor Servidor Rede Servidor Memória Arquivo Servidor Process o Servidor Impressã o Modo Usuário Modo Kernel Microkernel Hardware PROCESSO O conceito de processo é a base para a implementação de um sistema multiprogramável. O processador é projetado apenas para executar instruções, não sendo capaz de distinguir qual programa se encontra em execução.A gerência de um ambiente multiprogramável é função exclusiva do sistema operacional, que deve controlar a execução dos diversos programas e o uso concorrente do processador. A gerência do processador é uma das principais funções de um sistema operacional. Através dos processos, um programa pode alocar recursos, compartilhar dados e trocar informações. Modelo de Processos A maioria dos computadores modernos são capazes de realizar diversas atividades em paralelo. Enquanto roda um programa do usuário, o computador pode ler um disco ou utilizar a impressora. Em sistemas multiprogramados, a CPU é comutada de programa aprograma em períodos da ordem de milisegundos, dando ao usuário a impressão de paralelismo. O gerenciamento de atividades paralelas é difícil de ser implementado com eficiência. Entretanto, projetistas de sistemas operacionais ao longo dos anos vêm desenvolvendo modelos objetivando tornar esta tarefa mais simples. No modelo mais empregado atualmente, todos os programas executáveis no computador, muitas vezes incluindo subsistemas do sistema operacional, estão organizados na forma de processos. Conceitualmente, cada processo tem uma própria CPU virtual (tabela armazenando conteúdo de 61 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS registradores, contador de programa, etc). A posse da CPU real é passada periodicamente de processo a processo. O sistema pode ser visto como uma coleção de processos sendo executados em pseudo paralelismo. 1 Conforme definido anteriormente, a habilidade de executar múltiplos programas numa única CPU denomina-se multiprogramação. Em sistemas multiprogramados, a velocidade de execução de u m processo é função da quantidade de processos competindo pela CPU. Isto implica que o tempo de execução de um processo varia a cada nova execução, dependadendo da ―carga‖ da máquina. Ass im sendo, processos não devem ser programados com considerações intrínsecas de tempo. Qu ando são requeridas considerações de tempo real, medidas especiais devem ser tomadas para se assegurar que estas irão ocorrer. Concorrência Em muitos sistemas operacionais, processos frequentemente compartilham outros recursos além da CPU. Por exemplo, durante uma chamada de sistema um processo pode ter acesso a uma tabela mantida pelo núcleo. Neste caso, o núcleo deve inibir a comutação da CPU para outro processo, até que todas as operações na tabela forem efetuadas. Caso contr ário, a tabela fatalmente assumiria um estado inconsistente onde apenas algumas alterações foram processadas. Em situações como a exemplificada acima, a tabela é definida co mo um recurso compartilhado, e a parte do código que o manipula como uma região crítica . A execução de uma região crítica deve ser um procedimento controlado a fim de evitar que os recu rsos compartilhados atinjam estados inconsistentes. Regiões Críticas A chave para prevenir problemas em áreas compatilhadas é proibir que mais de um processo leia ou escreva dados compartilhados ao mesmo tempo, ou seja, deve-se garantir a mútua exclusão. Se for garantido que nenhum par de processos esteja executando ao mesmo tempo uma região crítica delimitando um mesmo recurso compartilhado, inconsistências são evitadas. Embora este quesito evite inconsistências, o mesmo não garante eficiência na utilização dos recursos compartilhados. Para assegurarmos uma boa solução, é necessário que: dois processos não estejam simultaneamente dentro de suas regiões críticas referentes ao mesmo recurso compartilhado (garantia de mútua exclusão); a garantia de mútua exclusão se dê independente da velocidade relativa dos processos ou número de CPUs; nenhum processo executando fora de regiões críticas bloqueie outro processo; nenhum processo espere um tempo arbitrariamente longo para executar uma região crítica (ou sofra ―estarvação‖). Vários algoritmos de controle visando garantir as propriedades acima foram propostos. Estes algoritmos são classificados segundo o modo com que esperam p ela autorização de entrada numa região crítica: espera ocupada (competindo pela CPU durante a espera) ou bloqueada (não competindo pela CPU). Todo algoritmo de mútua exclusão possui, invariavelmente, duas partes (implementadas como duas funções distintas). A primeira função é evocada quando o processo deseja iniciar a execução de uma região crítica. Quando esta função retorna, o processo está apto a executar a região crítica. No final da execução, o processo evoca a segunda função, anunciando que a região crítica já foi executada. Esta segunda função, via de regra, provoca o retorno da primeira função em outro processo. 62 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Para permitir que regiões críticas que acessam recursos com partilhados distintos possam ser executadas ao mesmo tempo, cada recurso compartilhado possui um identificador (via de regra um número inteiro). Assim sendo, as duas funções que compõem o alg oritmo de garantia de mútua exclusão possuem este identificador como parâmetro. Mútua Exclusão Com Espera Ocupada Nesta seção analisaremos várias propostas para garantir exclusão mútua nas regiões críticas, não permitindo que mais de um processo possam manipular um recurso compartilhado ao mesmo tempo. Em todas, o processo que está tentando acessar uma região crítica em execução por outro processo permanece em espera ocupada, isto é, competindo pela CPU mas sem avançar no seu processamento. Por esta razão, os métodos que empregam espera bloqueada são os mais utilizados na prática. Desabilitar Interrupções A solução mais simples é o método de desabilitar todas as interrupções quando se está entrando na região crítica, e reabilitá-las ao sair. Esta proposta não é muito atrativa, pois dá ao processo usuário poder de desabilitar todas as interrupções, inclusive aquelas que permitem o núcleo reassumir a CPU. Caso o processo não as reabilite por algum motivo, o sistema operacional jamais reassume o controle do hardware. Em outro aspecto, é conveniente para o sistema operacional desabilitar interrupções durante algumas instruções, enquanto está atualizando variáveis internas. Assim, desabilitar interrupções é uma solução útil para o sistema operacional, não para processos de aplicação. Variáveis LOCK Uma segunda tentativa leva-nos a uma solução por software. Considere uma variável simples e compartilhada LOCK, inicialmente igual a 0. Quando um processo deseja entrar em sua região crítica ele primeiro testa o LOCK. Se for 0, o processo altera para 1 e executa a região crítica. Se for 1 ele espera até que seja 0. Embora pareça uma boa solução, o qu e irá ocorrer se ambos testam uma variável de valor 0 ao mesmo tempo ? Alternância Estrita Esta proposta define uma variável TURN, inicialmente 0. Ela indica quem deve esperar e quem pode entrar na seção crítica. Se TURN for 0, o processo 0 pode e ntrar na região crítica. Ao sair, deve passar o valor de TURN para 1. Quando TURN é 1 o processo 1 pode entrar na seção crítica. Ao sair passa o valor de TURN para 0. 4 Este algoritmo garante a mútua exclusão. Entretanto, os processos estritamente se alternam na posse do recurso compartilhado. Isto faz com que um processo necessite aguardar o acesso a um recurso compartilhado por todos os demais até que chegue novamente a sua vez. O que ocorre quando o número de acessos for diferente entre os processos ? Mútua Exclusão com Espera Bloqueada Serão apresentados a seguir alguns mecanismos de garantia d e mútua exclusão que bloqueiam os processos quando tentam executar uma região crítica ―ocupa da‖. São mais eficientes que os anteriores, posto que processos bloqueados não competem pela CPU. Sleep e Wakeup Um dos métodos mais simples constitue-se do par sleep e wakeup. sleep é uma chamada de sistema que muda o estado de um processo em execução para bloqueado. Um processo bloqueado volta a tornar-se ativo quando outro o desbloqueia através da chamada wakeup. O método é o mesmo que 63 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS emprega variáveis LOCK operadas por instruções TSL, exceto que quando a variável apresenta valor 1, o processo executa sleep. O processo que altera o valor de LOCK para 0 ao sair da região crítica é o responsável por ativar um processo bloqueado (via wakeup). Infelizmente, com o emprego de apenas sleep e wakeup é fácil demonstrar e existência de um estado onde todos os processos encontram-se bloqueados. Esta situação é denominada deadlock. Semáforos São variáveis inteiras que contam o número de vezes que a operação wakeup tenha sido realizada. Duas operações, DOWN e UP (generalizações de sleep e wakeup) são definidas. A operação DOWN verifica se o valor do semáforo for maior que 0. Se o for, decrementa o valor e continua. Se o valor é 0, o processo é bloqueado. A operação UP incrementa o valor do semáforo. Se um ou mais processos estiverem bloqueados sobre aquele semáforo, um deles é escolhido pelo sistema para completar a operação DOWN (emitindo-lhe um wakeup). As operações com semáforos são atômicas ou indivisíveis, im plementadas com instruções TSL. Contadores de Evento Um outro tipo de variável de sincronização entre processos. Três operações são definidas para um contador de evento (E): READ(E) : retorna o valor corrente de E; ADVANCE(E) : incrementa atomicamente E; AWAIT(E,v) : bloqueia até que E v. Note que os contadores de eventos nunca decrescem e partem sempre de 0. Contadores de evento são mais convenientes que semáforos para problemas to tipo produtor-consumidor com buffer limitado. Monitores Semáforos e contadores de evento tornam simples a proteção de recursos compartilhados. Entretanto, uma simples troca na ordem da chamada das primitivas pode gerar uma situação de deadlock. Em suma, a utilização de semáforos e contadores de eventos deve se processar com extrema cautela. Monitores são uma proposta de mecanismo de sincronização de alto nível. Um monitor é uma coleção de procedimentos, variáveis e estruturas de dados agrupados em um bloco. Os processos podem acessar os procedimentos do monitor mas não suas estruturas internas. Monitores têm uma característica importante: somente um processo pode estar ativo no monitor em um dado instante (garantindo portanto a mútua exclusão). Monitores constituem-se em um conceito de linguagem de programação, ou seja, o compilador reconhece que os monitores são especiais e pode manusear as c hamadas do monitor diferentemente de outras chamadas. Esta é uma das desvantagens de monitores: precisam de linguagens de programação que os incorpore. A conclusão é que monitores, apesar de elegantes na manutenção de mútua exclusão, é de aplicação restrita, pois raras são as linguagens de programação que os incorporam. Comunicação Inter-processos Muitos autores consideram os mecanismos de mútua exclusão apresentados acima como formas de processos se comunicarem. Entretanto, preferimos considerar tais mecanismos como de sincronização inter-processos, usando o termo comunicação apenas quando ocorrer intercâmbio de informação entre processos. Sincronização são procedimentos de controle, normalmente usados para garantir mútua exclusão, e utilizados para geranciar a competição entre os processos. Comunicação, por sua vez, visa promover a cooperação entre os processos. 64 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Passagem de Mensagem Este método de comunicação entre processos usa duas chamadas de sistema: send e receive. Send (destino, mensagem) : envia mensagem a um processo destino. Receive (fonte, mensagem) : recebe mensagem de um processo fonte. Destino e fonte de mensagens são buffers alocados pelos processos para fins de envio e recepção de mensagens. Mensagens são estruturas tipadas ou não cujo conteúdo é interpretado unicamente pelos processos emissor e receptor da mensagem. Compartilhamento de Dados Processos podem se comunicar através do compartilhamento de uma área comum onde dados podem ser escritos por um e lidos por outro processo. O acesso a esta área comum deve ser disciplinado por um mecanismo de mútua exclusão (tipicamente semáforos)ou tornando as instruções de leitura e gravação atômicas. Duas primitivas são necessárias: STORE(posição, dado) : grava dados numa certa posição; FETCH(posição, dado) : acessa dados de uma certa posição. Chamada de Procedimentos Remotos Chamada de procedimentos remotos (ou RPC) é uma forma mais estruturada de troca de mensagens entre processos servidores e clientes. Um processo servidor dispõe de um conjunto de serviços que um processo cliente evoca como se evocasse um procedimento local. O cliente indica o serviço desejado ao servidor, passando parâmetros para sua execução, se for o caso. Recebida a requisição, esta é processada pelo servidor6 que retorna os resultados ao cliente. O envio e recepção de parâmetros e retornos se dá por troca de mensagens. Uma biblioteca de RPC possui duas primitivas básicas: REGISTER_RPC(serviço) : utilizada por servidores para anunciar que serviços estão aptos a processar; CALL_RPC(serviço, parâmetros, resultados) : utilizada por clientes para evocar serviços. Processos e Threads Processo é geralmente entendido como um programa em execução porém, na realidade, trata-se de uma estrutura mais complexa que contém, além do programa no seu formato executável, todas as informações necessárias (contexto) à execução e ao controle da execução do mesmo, como por exemplo: o contador de programa, pilhas, registradores e área de dados. O programa é uma entidade passiva, que pode ser visto como o conteúdo de um arquivo em disco, enquanto que o processo é uma entidade ativa, possuindo um contador de programa (PC), que especifica a próxima instrução a ser executada, e um conjunto de recursos a ele alocados. Nos sistemas operacionais mais antigos, cada processo possuía um único fluxo de controle, ou seja, as instruções são executadas seqüencialmente, uma de cada vez. Já nos sistemas mais mo-dernos, um processo pode, por sua vez, dar início a um ou mais subprocessos, que são executados em paralelo ou de forma concorrente com o processo pai e, para todos os efeitos, apresentam as mesmas características e particularidades de um processo qualquer, no tocante a contexto e fluxo de controle. Threads, por outro lado, representam uma nova concepção na forma de um processo pa-ralelizar a execução de partes do seu código. Os threads, conceitualmente, se assemelham a sub-processos porém, diferentemente destes, não possuem identidade própria e, portanto, não são inde-pendentes. Cada thread possui seu próprio contador de programa, sua pilha e seus registradores porém 65 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS compartilham todos o mesmo espaço de endereçamento, isto é, como se fossem uma única entidade . Nos sistemas tradicionais, cada processo tem seu próprio contexto e apenas um fluxo de controle são do tipo single thread. Freqüentemente, no entanto, é desejado ter-se múltiplos fluxos de controle que compartilhem do mesmo espaço de endereçamento e sejam executados de forma paralela (no caso de multiprocessamento) ou de forma concorrente (no caso de monoprocessa-mento), como se fossem processos separados. Threads satisfazem estes requisitos, pois compartilham do mesmo espaço de endereça-mento com o processo pai e com os demais threads, e podem ser executados de forma concorrente ou paralela (fig. VIII.1). O esquema de threads, no entanto, só pode ser utilizado quando for espe-cificamente suportado pelo sistema operacional ou quando da existência de um gerenciador de thre-ads. Os threads não são tão independentes como os processos e os subprocessos, uma vez que compartilham de um mesmo espaço de endereçamento e, por conseguinte, compartilham das mesmas variáveis globais, dos mesmos arquivos, das mesmas tabelas, etc. Uma vez que todo thread pode acessar todo o espaço virtual de endereçamento do processo pai e dos demais threads, ele pode ―ler e escrever‖ em qualquer local, mesmo na pilha dos outros threads - o que significa que não há qualquer forma de proteção de acesso entre os threads. Os threads compartilham a UCP da mesma forma que os processos o fazem, isto é, podem criar outros threads e podem ficar suspensos aguardando (em block waiting) pelo término de uma operação qualquer (system call). Contexto de um Processo O ambiente necessário a execução de um processo é formado pelos contextos de hardware e de software. O contexto de hardware é fundamental para que os processos possam se revezar no controle (utilização) da UCP, podendo ser interrompidos pelo SO e, posteriormente, reinicializados do ponto onde haviam parado sem qualquer solução de continuidade, isto é, como se nada tivesse ocorrido. A operação que possibilita tal revezamento é chamada de troca de contexto (context switch) e consiste basicamente em salvar o conteúdo dos registradores e carregá-los com os valores referentes ao processo que esteja ganhando o controle da UCP. O contexto de software especifica características do processo que influem na execução do mesmo, tais como: o número máximo de arquivos abertos, o tamanho do buffer para operações de E/S, etc. O Sistema Operacional cria para cada processo uma estrutura chamada PCB - Process Control Block, onde ele mantém todas as informações de contexto (hardware e software) do pro-cesso. O conteúdo e a estrutura do PCB variam de sistema para sistema, sendo que no exemplo mostrado na figura VIII.2 a seguir, ele consiste do estado do processo, da sua identificação, do registrador PC, dos demais registradores da UCP, de informações de escalonamento, de informações de memória, de informações de contabilização e de informações de entrada e saída. Estados de um Processo O procedimento de execução de um processo tem início com a criação do mesmo, carga do mesmo em memória, para que de lá possa ser escalado para tomar o controle da UCP e realizar seu processamento e, finalmente, terminado, quando da sua conclusão. Quando em memória, o proces-so pode estar num dos três estados seguintes: em execução, em espera pela ocorrência de um evento 66 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS previamente solicitado por ele mesmo ou, no estado de pronto para execução. Quando um processo em execução solicita um recurso que não está disponível no momento (como por exemplo a alocação de um arquivo ou de um periférico) ou cuja obtenção seja operacionalizada fora da UCP (como por exemplo leitura de registros em disco - DMA), ele automática-mente perde o controle da UCP e passa do estado de execução para o de espera. O processo estando no estado de espera passa para o estado de pronto para execução as-sim que tiver sua solicitação de recurso atendida pelo sistema. No estado de pronto ele está em condições de reiniciar sua execução e fica aguardando apenas chegar sua vez de retomar o controle da UCP. Nos sistemas preemptivos, isto é, que admitem interromper a execução de um processo toda vez que seu tempo (quantum) permitido para alocação da UCP expirar, pode ocorrer que um processo saia da UCP não para o estado de espera mas direto para o estado de pronto. Vê-se assim que um processo pode mudar de estado face um evento originado por ele próprio (eventos voluntários) ou pelo sistema (eventos involuntários). Estados de Execução de um Processo Dentro do estado de execução, para fins de proteção do sistema como um todo, são adotados níveis de prioridade que definem o que o processo está ou não autorizado a fazer. É a forma utilizada para evitar que processos dos usuários venham a danificar áreas do sistema operacional ou mesmo áreas reservadas a outros processos. Sincronização de Processos O compartilhamento de recursos entre processos pode gerar situações indesejáveis de in-consistência no acesso aos dados e de indisponibilidade no acesso aos recursos, a ponto de comprometer o sistema como um todo. A solução para estes casos é garantir a exclusão mútua, isto é, apenas um processo tem autorização para acessar o recurso de cada vez. O trecho do programa onde é feito o acesso ao recurso compartilhado é denominado região crítica e os mecanismos que implementam a exclusão mútua utilizam um protocolo de acesso à região crítica. Toda vez que um processo for executar sua região crítica, ele é obrigado a passar por um controle de entrada e outro de saída. Problemas de Sincronização Surgem a partir das tentativas de implementar a exclusão mútua. a) velocidade de execução dos processos A velocidade de execução dos processos pode interferir na operacionalização da exclusão mútua. No caso de um chaveamento simples entre dois processos, digamos A e B, sendo que o processo A consome um tempo de processamento bem mais longo que o processo B, pode levar a situação em que B se veja impossibilitado de entrar em sua região crítica por estar bloqueado pela execução do processo A fora da sua região crítica. b) “Starvation” É a situação onde um processo nunca consegue executar sua região crítica e, em conseqüência, nunca consegue acessar o recurso compartilhado. Este problema ocorre quando 2 ou mais processos estão na lista de espera por um recurso compartilhado. No momento em que o recurso é liberado, o sistema precisa determinar qual dos processos em espera deve ganhar acesso ao recur-so. Esta escolha pode ser: aleatória - um processo pode nunca ser escolhido e sofrer starvation; 67 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS por prioridade - um processo pode novamente permanecer indefinidamente na fila de es-pera face a constante chegada de processos de maior prioridade; fila tipo FIFO - evita starvation porém pode prejudicar o desempenho de programas com maior prioridade de execução. · Sincronização Condicional É quando um recurso compartilhado não se encontra pronto para ser utilizado e, nesse caso, o processo precisa ser mantido em estado de espera até o recurso ficar pronto. Este tipo de sincronização aparece em qualquer operação onde existam processos gerando serviços e processos consumindo estes mesmos serviços. Um exemplo clássico deste tipo de sincronização é o da gravação de um buffer por um processo e leitura por outro. Ambos os processos envolvidos devem ser sincronizados de forma a não tentarem gravar um buffer cheio ou ler um buffer vazio. Deadlock É conseqüência do compartilhamento exclusivo e ocorre sempre que um ou mais processos estiverem esperando por um evento (recurso) que jamais ocorrerá. Caracteriza-se por uma espera circular onde dois ou mais processos aguardam pela liberação de recursos para que possam continuar suas tarefas. Exemplo, o processo "A", da figura VIII.5, detém o recurso X e espera pelo recurso Y, por outro lado, o processo "B" detém o recurso Y e espera pelo X. a) condições para ocorrência de deadlock · cada recurso só pode estar alocado a um único processo em um determinado instante (exclusão mútua); · um processo, além dos recursos já alocados, pode ficar na espera por outros; · um recurso não pode ser retirado de um processo porque outros processos o estão desejando (nãopreempção); · um processo pode aguardar por um recurso que esteja alocado a outro processo e vice-versa (espera circular). Dois procedimentos podem ser implementados para tratamento de deadlocks: previnir sua ocorrência ou, detetar sua ocorrência. Escalonamento de Processos Os principais objetivos do escalonamento (scheduling) de processos são: · manter a UCP ocupada a maior parte do tempo; · balancear a utilização do processador pelos processos em execução; · maximizar o throughput (capacidade de atendimento a processos) do sistema; e · garantir tempos de resposta razoáveis aos usuários interativos. Para atender tais objetivos, muitas vezes conflitantes, os SOs precisam levar em consideração: as características dos processos em execução (batch, interativo, tempo-real, CPU-bounded, IO_bounded); · a disponibilidade de recursos; · as características da instalação. O escalonamento dos processos é realizado por um módulo do sistema operacional conhe-cido como dispatcher (scheduler). Existem diversos algoritmos utilizados para tal finalidade e cada um apresenta características próprias favorecendo um ou outro critério para a escolha do próximo 68 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS processo a receber o controle da UCP. Os critérios geralmente considerados incluem os seguintes parâmetros ou medidas de eficiência: · utilização da UCP - o desejado é manter a UCP p mais ocupada possível. O grau de uti-lização da UCP varia de 0 (idle) a 100%. Geralmente a ocupação da UCP gira no entor-no dos 40% para sistemas com carga moderada e aproximadamente 90% para os com carga pesada. · throughput - medida que representa o número de processos concluídos por unidade de tempo (ex. 10 processos/segundo). · turnaround time - mede o tempo total gasto na execução de um processo, desde o mo-mento em que ele é submetido até o instante em que é concluído. · waiting time - mede apenas o tempo em que o processo fica aguardando por execução na fila de processos prontos (ready queue). · response time - mede o tempo decorrido entre a submissão do processo e o instante em que o mesmo gera a primeira resposta ao usuário. Escalonamento de Processos Quando mais de um processo está ativo (pronto para executar), cabe ao sistema operacional decidir qual terá a posse da CPU. A parte do sistema operacional que toma esta decisão é chamada escalonador e o algoritmo utilizado é o algoritmo de escalonamento. Vários critérios devem ser observados por um algoritmo de escalonamento: 1. progresso: garantir que cada processo tenha acesso à CPU; 2. eficiência: manter a CPU ocupada praticamente 100% do tempo; 3. tempo de resposta: minimizar o tempo de resposta na execução dos processos, principalmente os interativos (editores, planilhas, etc); 4. tempo de espera: minimizar o tempo de espera de serviços não interativos (compilação, impressão, etc); 5. vazão : maximizar o número de processos executados por hora. É importante observar que alguns desses objetivos são contraditórios. Se um algoritmo favorece o escalonamento de processos interativos certamente estará comprometendo os não interativos. Vejamos agora alguns algoritmos de escalonamento. Algoritmos de Escalonamento Escalonamento Round Robin Este é o mais antigo e simples algoritmo de escalonamento. Cada processo é executado por um intervalo de tempo (quantum). Se o processo ainda estiver executando ao final do quantum, ele é suspenso e a CPU é alocada a outro processo. Se o processo acabar ou for bloqueado antes do final do quantum, a CPU também é passada a outro processo. A única questão a ser analisada é o tamanho do quantum. Se for muito pequeno, diminui a eficiência da CPU, pois a alocação da CPU para outro processo implica num certo overhead. Se for muito grande, degrada a resposta para os processos interativos. Algoritmos com Prioridades O algoritmo Round Robin faz a consideração que todos os processos são de igual importância. Certas aplicações, como controle de processos industriais, demandam um algoritmo de escalona-mento com prioridades. A idéia básica é que cada processo tem uma prioridade e processos com prioridades 69 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS superiores devem ser executados primeiro. Para prevenir que processos de alta prioridade executem indefinidamente, o escalonador, via de regra, diminui a prioridade dos processos com o aumento de seu respectivo tempo de execução. Múltiplas Filas Este é um algoritmo que define classes com prioridades. Processos na classe de menor prioridade são executados por um quantum. Processos na classe seguinte, por dois quanta. Na próxima classe por 4 quanta, e assim por diante. Quando um processo utiliza todos os quanta a ele alocados, o mesmo é interrompido e sua classe tem a prioridade diminuída. Este algoritmo diminui o número de comutações da CPU entre os processos ativos. Tarefas Pequenas Primeiro Este algoritmo é designado para aplicações não interativas , onde o tempo médio de execução é conhecido a priori. O algoritmo define que as tarefas menores devem ser executadas primeiro. Provase que esta política minimiza o tempo médio de espera dos Jobs. Algoritmo “Policy-Driven” Este algoritmo particiona a CPU de forma equânime entre os usuários (não entre os processos). O algoritmo define que se existirem n usuários ligados ao sistema, e cada usuário deverá receber1/n do poder da CPU. Para isto, o sistema deve manter informações do tempo de CPU que cada usuário já dispôs desde que entrou no sistema, e do instante de tempo que cada usuário ligou-se ao sistema. Escalonamento em Dois Níveis Até agora foi considerado que todos os processos residem em memória primária. Entretanto se esta memória for insuficiente, processos ativos podem ser armazenados temporariamente em memória secundária (tipicamente disco). O meio mais prático para controlar a comutação de processos é definir dois níveis de escalonamento. Um escalonador de baixo nível se restringe a troca de processos que estão na memória primária no momento. Um escalonador de alto nível decide sobre a troca dos processos entre as memórias primária e secundária. Semáforos Semáforo é um mecanismo de sincronização interprocessos composto das operações DOWN e UP. Via de regra, define-se um semáforo para cada recurso compartilhado. A execução da parte código que acessa tais recursos (região crítica) é abraçada pelas operações DOWN e UP. Processos definem/acessam semáforos com a chamada de sistema semget. Esta chamada requer três parâmetros: um identificador global para um array de semáforos; o número de semáforos contido no array; e um flag estipulando ações relativas a permissões e criação. Operações em semáforos se processam através da chamada de sistema semop. Esta chamada requer três parâmetros: o identificador local do semáforo (obtido via semget); um array de estruturas sembuf; e o número de estruturas no array. Componentes do processo Um processo pode ser entendido inicialmente como um programa em execução, que tem suas informações mantidas pelo sistema operacional. Num sistema multiusuário, cada usuário tem a impressão de possuir o processador e todos os demais recursos reservados exclusivamente para si, mas isto não é verdade. Todos os recursos estão sendo compartilhados, inclusive a CPU. Neste caso, o processador executa o processo do usuário por um 70 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS intervalo de tempo e, no instante seguinte, poderá estar processando um outro programa, do mesmo ou de outro usuário. Para que a troca de processos possa ser feita sem problemas, é necessário que todas as informações do programa que está sendo interrompido sejam guardadas, para que ele possa retornar à CPU exatamente do ponto em que parou, não lhe faltando nenhuma informação vital à sua continuação. Todas as informações necessárias à execução de um programa fazem parte do processo. Um processo também pode ser definido como o ambiente onde o programa é executado. Este ambiente, além das informações sobre a execução, possui também a quantidade de recursos do sistema que o programa pode utilizar,como espaço de endereçamento, tempo do processador e área em disco. Um processo é formado por três partes: contexto de software, contexto de hardware e espaço de endereçamento, que juntas mantêm todas as informações necessárias à execução de um programa. Estrutura do processo: Contexto de Software ________ ________ ________ Programa Contexto de Hardware Espaço de endereçamento Contexto de Software: neste contexto são especificadas características e limites dos recursos que podem ser alocados pelo processo, como número máximo de arquivos abertos, prioridade de execução, número máximo de linhas impressas, etc. Muitas destas características são criadas no momento da criação do processo, quando da sua alocação. O sistema operacional obtém, a partir do cadastro de usuários e do cadastro de contas no sistema, as informações e características que valerão para o processo. O contexto de software é composto por tr?es grupos de informações: Identificação: neste grupo são guardadas informações sobre o usuário que criou o processo, e, em função disso, suas áreas de atuação no sistema. Quotas: são os limites de recursos do sistema que um processo pode alocar, como área utilizada em disco, em memória, limite de linhas impressas, número máximo de arquivos abertos, número máximo de operações de E/S pendentes, tempo limite de CPU, etc. Privilégios: diz respeito principalmente às prioridades assumidas pelo processo durante sua execução. Contexto de Hardware: armazena o conteúdo dos registradores gerais da CPU, além dos registradores de uso específico. Quando um processo está em execução, o seu contexto de hardware está armazenado nos registradores da CPU. No momento em que o processo perde a utilização da CPU, o sistema salva as informações no contexto de hardware do processo. 71 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS A troca de um processo por outro no processador, comandada pelo sistema operacional, é denominada troca de contexto, que consiste em salvar o conteúdo dos registradores do processo que está deixando a CPU e carrega-los com os valores referentes ao do novo processo que irá executar. Essa operação resume-se em substituir o contexto de hardware de um processo pelo de outro. Espaço de endereçamento: é a área de memória pertencente a um processo onde as instruções e os dados do programa são armazenados para execução. Cada processo possui seu próprio espaço de endereçamento, que deve ser devidamente protegido do acesso dos demais processos. Os contextos de software e de hardware não fazem parte do espaço de endereçamento . Bloco de controle do processo: é a estrutura de dados que compõe o processo, contendo os contextos de software e de hardware e o espaço de endereçamento. O BCP reside em memória, numa área reservada ao sistema operacional. Estados do processo Num sistema multiprogramável, um processo não deve alocar a CPU com exclusividade, de forma que possa existir um compartilhamento no uso do processador. Os processos passam por diferentes estados ao longo do processamento, em função de eventos gerados pelo sistema operacional, pelo hardware, ou pelo próprio programa. São estados possíveis de um processo: Criação: neste estado o processo está sendo alocado na memória, sendo criado no sistema. Todos os recursos necessários à execução do processo são reservados durante a passagem do processo por este estado, o que acontece uma única vez. Vários processos podem estar neste estado, ao mesmo tempo. Pronto: é o estado onde os processos, depois de criados ou quando retornam do tratamento de uma interrupção, permanecem aguardando a liberação da CPU para que possam iniciar ou continuar seu processamento. É como se fosse uma fila, gerenciada pelo sistema operacional, que se incumbe de organizar os processos de acordo com as informações contidas no contexto de software (identificação, quotas e privilégios). Vários processos podem estar neste estado, ao mesmo tempo. Execução: é onde o processo efetivamente utiliza a CPU. Ele permanece no processador até que seja interrompido ou termine sua execução. Neste estado, somente um processo pode permanecer de cada vez, já que existe apenas um processador. Espera: neste estado estão todos os processos que sofreram algum tipo de interrupção de E/S, onde permanecem até que a intervenção seja resolvida. Vários processos podem estar neste estado, ao mesmo tempo. Saída: é o estado final do processo, quando este termina seu processamento. Vários processos podem estar neste estado, ao mesmo tempo. Mudanças de estado do processo Um processo muda de estado diversas vezes durante sua permanência no sistema, devido aos eventos ocorridos durante sua execução. São mudanças possíveis: Criação Pronto: o processo foi criado, tem seus recursos alocados, e está apto a disputar o uso da CPU. Pronto Execução: o processo é o primeiro da fila de pronto e a CPU fica disponível. Neste momento o processo passa a ocupar a CPU, permanecendo em execução até que seja interrompido ou termine sua execução. 72 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Execução Pronto: o processo foi interrompido por fatia de tempo ou por prioridade. Ainda precisa de mais tempo na CPU para terminar sua execução, não tem nenhuma intervenção pendente, por isso volta à fila de pronto para disputar novamente o uso da CPU. Execução Espera: esta transição acontece quando o processo foi interrompido por E/S. Significa que deve permanecer no estado de espera até que a interrupção seja tratada pelo sistema. Neste estado o processo fica impedido de disputar o uso da CPU. Espera Pronto: Após o término do tratamento da interrupção, o processo volta à fila de pronto para disputar novamente o uso da CPU. Execução Saída: o processo terminou, e não mais disputará o uso da CPU. A seguir, a figura mostra as mudanças possíveis de estado de um processo. Criação Pronto Execução Saída Mudanças de estado de um processo Espera Tipos de processos Além dos processos do usuário, a CPU também executa processos do sistema. São aqueles que oferecem os serviços do sistema operacional aos usuários, como criação/eliminação de processos, tratamento de interrupção e todos aqueles correspondentes às funções do sistema já estudadas. Estes executam sempre, com certa prioridade, concorrendo com os processos do usuário. Os processos em execução, do usuário, podem assumir dois tipos diferentes, de acordo com suas características de uso de CPU e periféricos: Processo CPU-bound: é aquele processo que utiliza muito a CPU. Ele ganha uma fatia de tempo e a utiliza por inteiro, sem desperdiçar nenhum tempo. É o caso de programas científicos, de cálculo numérico, estatística, matemática, e também na área de simulação. Normalmente fazem pouca ou nenhuma entrada de dados, e muito processamento. Processo I/O-bound: é o tipo de processo que utiliza muito mais E/S do que CPU. Aplicações em Banco de Dados, onde se faz consultas e atualizações constantes em arquivos em disco são um bom exemplo deste tipo de processo. De acordo com essas características, podemos dizer que este tipo de processo permanece mais tempo em espera (tratando interrupções) do que propriamente em execução, ocupando a CPU por períodos mínimos de tempo. Gerência do Processador 73 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Funções Com o surgimento dos sistemas multiprogramáveis, onde múltiplos processos poderiam permanecer na memória e disputar o uso de um único processador, a gerência do processador tornou-se uma das atividades mais importantes em um sistema operacional. A partir do momento em que vários processos podem estar no estado de pronto, devem ser estabelecidos critérios para definir qual processo será escolhido para fazer uso do processador. Tais critérios compõem a política de escalonamento, que é a base da gerência do processador e da multiprogramação em um sistema operacional. Dentre as funções da gerência do processador, podemos citar: manter o processador ocupado a maior parte do tempo. balancear o uso da CPU entre processos, privilegiar a execução de aplicações críticas, maximizar o throughput e oferecer tempos de resposta razoáveis aos usuários interativos. Cada sistema operacional possui sua política de escalonamento adequada ao seu propósito e às suas características. Sistemas de tempo compartilhado, por exemplo, possuem requisitos de escalonamento distintos dos sistemas de tempo real. Critérios de escalonamento Utilização do processador: corresponde a uma taxa de utilização, que na maioria dos sistemas varia entre 30 e 90%. Uma utilização abaixo dos 30% indicaria um sistema ocioso, com carga de processamento baixa, enquanto uma taxa de utilização acima dos 90% pode indicar um sistema bastante carregado, próximo da sua capacidade máxima (em alguns casos tal situação pode levar a um crash – travamento do sistema). Throughput: é o número de processos executados em um determinado intervalo de tempo. Quanto maior o throughput, maior o número de tarefas executadas em função do tempo. A maximização do throughput é desejada na maioria dos sistemas. Tempo de Processador: é o tempo que um processo leva no estado de execução, durante seu processamento. As políticas de escalonamento não interferem neste parâmetro, sendo este tempo função apenas do código executável e da entrada/saída de dados. Tempo de Espera (pela CPU): é todo o tempo que o processo permanece na fila de pronto, aguardando a liberação da CPU para ser executado. A redução deste tempo de espera é desejada pela maioria das políticas de escalonamento. Tempo de Turnaround: é o tempo total que o processo permaneceu no sistema, desde sua criação até o momento em que é encerrado. São contados os tempos de alocação de memória, espera na fila de pronto e interrupção (E/S). Tempo de Resposta: é o tempo decorrido entre uma requisição ao sistema e o instante em que a resposta começa a ser exibida. Em sistemas interativos, como aplicações on-line ou acesso à Web, os tempos de resposta devem ser da ordem de apenas poucos segundos. Escalonamentos Não-Preemptivos e Preemptivos Escalonamentos do tipo não-preemptivos são aqueles onde o sistema operacional não pode interromper o processo em execução para retirá-lo da CPU. Assim sendo, se nenhum evento externo ocorresse durante a execução do processo, este permanecia na CPU até terminar ou então alguma instrução do próprio programa o desviasse para o estado de espera (operação de E/S). Já os escalonamentos preemptivos são caracterizados pela possibilidade de o sistema operacional interromper o processo em execução para retirá-lo da CPU e dar lugar a outro. Neste caso o processo 74 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS retirado da CPU volta ao estado de pronto, onde permanece aguardando nova oportunidade de ocupar a CPU. Com o uso da preempção, é possível ao sistema priorizar a execução de processos, como no caso de aplicações em tempo real. Outro benefício é a possibilidade de implementar políticas de escalonamento que compartilhem o processador de uma maneira mais uniforme, balanceando o uso da CPU entre os processos. São escalonamentos não-preemptivos: FIFO: o processo que chegar primeiro à fila de pronto é selecionado para execução, e permanece utilizando o processador até terminar sua execução ou ser interrompido por E/S. Neste caso, o próximo processo da fila de pronto é selecionado para execução. Todo processo que chega à fila de pronto entra no final desta fila, conservando a ordem de chegada na fila, até ser escalonado novamente. Apesar de simples, este escalonamento apresenta algumas deficiências, principalmente no que diz respeito à dificuldade de se prever o início da execução de um processo, já que a ordem de chegada á fila de pronto deve ser observada à risca. Outro problema é quanto aos tipos de processo, onde os CPU-bound levam vantagem no uso do processador em relação aos do tipo I/O-bound, pois o sistema não trata este tipo de diferença. O escalonamento FIFO foi inicialmente implementado em sistemas monoprogramáveis, sendo ineficiente se aplicado em sistemas interativos de tempo compartilhado. Abaixo, um exemplo de escalonamento utilizando o método FIFO: a ordem de chegada dos processos (A, B, C) na fila de pronto foi obedecida, e, não tendo sido interrompidos por E/S, os processos executaram inteiramente até terminar, de acordo com seus tempos necessários para execução. 0 10 18 27 Processo A Processo B Processo C 10 u.t. 8 u.t. 9 u.t. SJF (Shortest Job First): este escalonamento seleciona o processo que tiver o menor tempo de processador ainda por executar. Desta forma, o processo que estiver na fila de pronto com menor necessidade de tempo de CPU para terminar o seu processamento será o escolhido para ocupar a CPU. Funciona com um parâmetro passado ao sistema via contexto de software, onde o tempo estimado para o processo é informado baseando-se em estatísticas de execuções anteriores. Como exemplo, vamos utilizar os mesmos processos executados no escalonamento FIFO acima, com seus respectivos tempos de execução em u.t. (unidades de tempo): processo A com 10 u.t., processo B com 8 u.t, e o processo C com 9 u.t. Como neste escalonamento o que importa é o tempo de execução, a nova ordem de escalonamento para utilização da CPU será B, C e A, como segue: 0 8 17 27 Processo B Processo C Processo A Cooperativo: este escalonamento busca aumentar o grau de concorrência no processador. Neste caso, um processo em execução pode voluntariamente liberar o processador retornando à fila de pronto, possibilitando que um novo processo seja escalonado, permitindo melhor distribuição do tempo do processador. A liberação da CPU é uma tarefa exclusiva do programa em execução, que de 75 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS maneira cooperativa libera o processador para um outro processo. Neste mecanismo, o processo em execução verifica periodicamente uma fila de mensagens para saber se existem outros processos na fila de pronto. Porém, como a interrupção do processo não depende do sistema operacional, situações indesejáveis podem ocorrer, como por exemplo, se um programa em execução não verificar a fila de mensagens, os demais programas não terão chance de executar enquanto a CPU não for liberada. As primeiras versões do Windows chegaram a utilizar este tipo de escalonamento. São escalonamentos preemptivos: Circular: é um tipo de escalonamento projetado especialmente para sistemas em tempo compartilhado. É muito semelhante ao FIFO (obedece a ordem de chegada á fila de PRONTO), mas quando um processo passa para o estado de execução há um limite de tempo para o uso contínuo do processador, chamado fatia de tempo (time-slice) ou quantum. Assim, toda vez que um processo é selecionado para execução uma nova fatia de tempo lhe é concedida. Caso esta fatia de tempo expire, o sistema operacional interrompe o processo, salva seu contexto e o direciona para a fila de PRONTO. Este mecanismo é conhecido como preempção por tempo. A principal vantagem deste escalonamento é não permitir que um processo monopolize a CPU. Outrossim, uma desvantagem é que os processos CPU-bound são beneficiados no uso do processador em relação aos processos I/Obound, pois tendem a utilizar totalmente a fatia de tempo recebida. A figura a seguir mostra o escalonamento circular com 3 processos, onde a fatia de tempo é igual a 2 u.t. No exemplo não estão sendo levados em consideração tempos de troca de contexto entre os processos, nem o tempo perdido em operações de E/S. Os processos A, B e C, gastam 10 u.t, 6 u.t e 3 u.t., respectivamente. A B C u.t. 2 4 6 8 10 11 17 Por Prioridades: funciona com base num valor associado a cada processo, denominado prioridade de execução. O processo com maior prioridade na fila de PRONTO é sempre o escolhido para ocupar o processador, sendo os processos com prioridades iguais escalonados pelo critério FIFO. Neste escalonamento o conceito da fatia de tempo não existe. Como conseqüência disto, um processo em execução não pode sofrer preempção por tempo. Neste escalonamento a perda do uso do processador somente ocorrerá no caso de uma mudança voluntária para o estado de espera (interrupção por E/S), ou quando um outro processo de prioridade maior passa (ou chega) para o estado de pronto. Neste caso o sistema operacional interrompe o processo em execução, salva seu contexto e o coloca na fila de pronto, dando lugar na CPU ao processo prioritário. Este mecanismo é chamado de preempção por prioridade. A figura a seguir mostra a execução dos processos A, B e C, com tempos de execução de 10, 4 e 3 u.t. respectivamente, e valores de prioridades de 2, 1 e 3, também respectivamente. Na maioria dos sistemas, valores menores correspondem à MAIOR prioridade. Assim, a ordem de execução será invertida para B, A e C. 76 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS A B C 4 14 17 u.t. A prioridade de execução faz parte do contexto de software do processo, e pode ser estática (quando não pode ser alterada durante a existência do processo) ou dinâmica (quando pode ser alterada durante a existência do processo). Este escalonamento é muito usado em sistemas de tempo real, com aplicações de controle de processos, controle de tráfego (sinais de trânsito, de trens/metrô, aéreo), robótica, entre outros. Escalonamento Circular com Prioridades: implementa o conceito de fatia de tempo e de prioridade de execução associada a cada processo. Neste escalonamento, um processo permanece no estado de execução até que termine seu processamento, ou voluntariamente passe para o estado de espera (interrupção por E/S), ou sofra uma preempção por tempo ou prioridade. A principal vantagem deste escalonamento é permitir um melhor balanceamento no uso do processador, com a possibilidade de diferenciar o grau de importância dos processos através da prioridade (o Windows utiliza este escalonamento). Por Múltiplas Filas: Este escalonamento implementa várias filas de pronto, cada uma com prioridade específica. Os processos são associados às filas de acordo com características próprias, como importância da aplicação, tipo de processamento ou área de memória necessária. Assim, não é o processo que detém a prioridade, mas sim a fila. O processo em execução sofre preempção caso um outro processo entre em uma fila de maior prioridade. O sistema operacional só pode escalonar processos de uma fila quando todas as outras filas de maior prioridade estejam vazias. Os processos sempre voltam para a mesma fila de onde saíram. Por Múltiplas Filas com Realimentação: semelhante ao anterior, porém permitindo ao processo voltar para uma outra fila de maior ou menor prioridade, de acordo com seu comportamento durante o processamento. O sistema operacional identifica dinamicamente o comportamento de cada processo e o redireciona para a fila mais conveniente ao longo de seu processamento. É um algoritmo generalista, podendo ser implementado na maioria dos sistemas operacionais. GERENCIAMENTO DE MEMÓRIA Memória é um importante recurso que deve ser cuidadosamente gerenciado. Enquanto a capacidade de armazenamento dos computadores vem crescendo continuamente, a complexidade do software cresce talvez à taxas maiores. A parte do sistema operacional que gerencia a memória é chamada de gerenciador de memória. Dentre outras tarefas, o gerenciador de memória monitora qu ais partes da memória estão em uso e quais estão disponíveis; aloca e libera memória para os pro cessos; gerencia a permuta de processos entre memória principal e secundária (quando a memória principal não é capaz de abrigar todos os processos). 77 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Gerenciamento de Memória Sem Permuta ou Paginação Sistemas de gerenciamento de memória podem ser divididos em duas classes: aqueles que movem processos entre a memória principal e secundária (tipicamente disco) durante a execução, e aqueles que mantêm os processos fixos em memória primária. N aprimeira classe, o gerenciamento é baseado em técnicas deswapping (permuta) ou de paginação . Monoprogramação O esquema mais simples possível de gerenciamento de memória consiste em ter-se somente um processo na memória durante toda a sua execução. O usuário carrega um programa do disco ou fita para a memória, podendo este fazer uso de toda a máquina. Se a memória for insuficiente, o programa simplesmente tem sua execução rejeitada. Embora essa técnica era comum em meados da década de sessenta, ela não é mais utilizada. Multiprogramação e Uso da Memória Embora a monoprogramação seja usada em pequenos computadores, em grandes computadores com múltiplos usuários ela é proibitiva. Grandes computadores frequentemente provêem serviços interativos para vários usuários simultaneamente. Para tal habilidade de ter-se mais de um processo na memória num mesmo instante de tempo é imprescindível por razões de desempenho. Uma outra razão para ter-se a multiprogramação, é que muitos processos gastam uma substancial fração do seu tempo para completar E/S em disco. É comum para u m processo permanecer em um loop lendo um bloco de dados de um arquivo em disco e então realizando alguma computação sobre o conteúdo dos blocos lidos. Se for gasto 40 mseg para ler um bloco e a computação demanda apenas 10 mseg, sem a multiprogramação a CPU estará desocupada esperando pelo acesso ao disco durante 80% do tempo. Modelagem da Multiprogramação Quando a multiprogramção é usada, o percentual de utilização da CPU aumenta. A grosso modo, se a média dos processos utilizam CPU somente 20% do tempo que permanecem na memória, com 5 processos em memória, a CPU deverá estar ocupada o tempo todo. Este modelo é otimista, entretanto, pois assume que os 5 processos nunca estejam esperando por E/S ao mesmo tempo. Multiprogramação com Partições Fixas Se adotarmos a estratégia de admitir mais de um processo na memória por vez, devemos estabelecer uma estratégia de organização da memória. A estratégia mais simples consiste em dividir a memória em (possilvelmente diferentes) n partições. Estas partições podem, por exemplo, ser esta-belecidas na configuração do sistema operacional. Quando um processo inicia, este pode ser colocado em uma fila d e entrada para ocupar a menor partição de tamanho suficiente para acomodá-lo. Desde que as partições são fixas, qualquer espaço em uma partição não usado pelo processo é perdido. Este sistema, com partições fixas definidas pelo operador, foi usado pelo sistema operacional OS/360 nos grandes mainframes da IBM por muitos anos. Ele era chamado de MFT (Multiprogra-ming with a Fixed number of Task). Ele é simples de se entender e igualmente simples de implemen-tar: os processos que chegam são colocados em uma fila até que u ma partição adequada seja liberada, quando então são carregados e executados. 78 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Swapping (Permuta) Num sistema operando em batch, a organização da memória em partições fixas é simples e efetiva. Quanto mais jobs estiverem na memória, mais a CPU estará ocupada e não há razão para usar algo mais complicado. Com time-sharing, a situação é diferente: há normalmente mais usuários que memória para armazenar os seus processos, sendo então necessário mover temporariamente processos para disco. Obviamente, para continuar sua execução, um processo movido para disco deve ser trazido novamente para a memória. Multiprogramação com Partições Variáveis Em princípio, um sistema que utiliza swapping pode ser baseado em partições fixas. Sempre que um processo é bloqueado, ele pode ser movido para o disco e um outro processo trazido do disco para a sua partição em memória. Na prática, partições fixas são pouco atrativas quando a área de memória é escassa pois muita memória é perdida por programas muito menores que o tamanho da partição. Assim sendo, um novo sistema de gerenciamento de memória foi desenvolvido, chamado gerenciamento com partições variáveis. Gerenciamento de Memória com Mapa de Bits Com um mapa de bits, a memória é dividida em unidades de alocação, desde um pequeno número de palavras até muitos kilobytes. Para cada unidade de alocação existe um bit no mapa de bits, que é 0 se a unidade estiver livre e 1 caso esteja ocupada (ou vice-versa). A figura 4.6 mostra parte da memória e o correspondente mapa de bits. O tamanho de cada unidade de alocação é uma importante característica de projeto. Para pequenas unidades de alocação tem-se um mapa de bits maior. Entret anto, mesmo com uma unidade de alocação tão pequena como com 4 bytes, 32 bits de memória irão requerer somente 1 bit no mapa (3% da memória). Se a unidade de alocação for escolhida grand e, o mapa de bits será pequeno, mas memória considerável pode ser desperdiçada se o tamanho do processo não for um múltiplo exato da unidade de alocação. Um mapa de bits (ocupando uma porção fixa da memória) provê uma maneira simples de gerenciar memória, uma vez que o tamanho do mapa de bits depende som ente do tamanho da memória e do tamanho da unidade de alocação. O problema principal com i sto é que quando se decide trazer um processo de k unidades de alocação para a memória, o gerenciador de memória deve pesquisar no mapa de bits uma sequência de consecutivos bits 0 no mapa. Esta operação é lenta, razão pela qual os mapas de bits são evitados na prática. Gerenciamento de Memória com Listas Encadeadas Outra maneira de gerenciar a memória é manter uma lista de alocações e segmentos de memória livre, onde um segmento é um processo ou um buraco entre dois processos. A memória da figura 4.6(a) é representada na mesma figura (c) como uma lista encadeada de segmentos. Cada entrada da lista especifica um buraco (B) ou um processo (P), contendo o endereço onde começa, o tamanho, e um ponteiro para a próxima entrada da lista. Neste exemplo, a lista de segmentos é mantida ordenada por endereços. A vantagem desse método é que quando o processo termina ou é movido para o disco, a atualização da lista é direta. Na finalização de um processo, ao seu lado teremos processos ou buracos. Quatro situações podem ocorrer. Quando processos e buracos são mantidos na lista ordenada por endereços, vários algoritmos podem 79 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS ser usados para alocar memória, a fim de criar ou permutar processos. Gerência de Memória / Memória Virtual Historicamente, a memória principal sempre foi vista como um recurso escasso e caro. Uma das maiores preocupações dos projetistas foi desenvolver sistemas operacionais que não ocupassem muito espaço de memória e, ao mesmo tempo, otimizassem a utilização dos recursos computacionais. Mesmo atualmente, com a redução do custo e o aumento considerável da capacidade da memória principal, seu gerenciamento é dos fatores mais importantes no projeto e implementação dos sistemas operacionais. Enquanto nos sistemas monoprogramáveis a gerência de memória não é muito complexa, nos sistemas multiprogramáveis essa gerência se torna crítica, devido à necessidade de se maximizar o número de usuários e aplicações utilizando eficientemente o espaço da memória principal. Funções Geralmente, os programas são armazenados em memórias secundárias, de uso permanente e não voláteis, como discos ou fitas. Como o processador somente executa o que está na memória principal, o sistema operacional deve sempre transferir programas da memória secundária para a principal antes de serem executados.Como o tempo de acesso às memórias secundárias é muito superior ao tempo de acesso à memória principal, o sistema operacional deve buscar reduzir o número de operações de E/S (acessos à memória secundária) a fim de não comprometer o desempenho do sistema. A gerência de memória deve tentar manter na memória principal o maior número de processos residentes, permitindo maximizar o compartilhamento do processador e demais recursos computacionais. Mesmo não havendo espaço livre, o sistema deve permitir que novos processos sejam aceitos e executados. Outra preocupação na gerência de memória é permitir a execução de programas maiores do que a memória física disponível. Em um ambiente de multiprogramação o sistema operacional deve proteger as áreas de memória ocupadas por cada processo, além da área onde reside o próprio sistema. Caso um programa tente realizar algum acesso indevido à memória, o sistema deve, de alguma forma, impedir o acesso. 80 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Alocação Contígua Simples Este tipo de alocação foi implementado nos primeiros sistemas operacionais, embora ainda nos dias de hoje esteja presente em alguns sistemas monoprogramáveis. Nesse modelo, a memória principal é dividida em duas partes, uma para o sistema operacional e a outra para o programa do usuário. Dessa forma, o programador deve desenvolver suas aplicações preocupado apenas em não ultrapassar o espaço de memória disponível. Neste esquema o usuário tem total controle sobre toda a memória, exceto naquela área onde reside o sistema operacional, cujo endereçamento é protegido por um registrador, impedindo acesso indevido pelo usuário. Sistema Operacional X registrador Área para programas Proteção na alocação contígua simples Apesar de simples implementação e código reduzido, a alocação contígua simples não permite a utilização eficiente dos recursos do sistema, pois apenas um usuário pode dispor destes recursos. Há inclusive um desperdício de espaço de memória, caso o programa não venha a ocupar toda a área reservada para ele. Sistema Operacional Programa do Usuário Área livre Sub-utilização da memória principal Segmentação de Programas Na alocação contígua simples todos os programas estão limitados ao tamanho da memória principal disponível para o usuário. Uma solução encontrada para o problema é dividir o programa em módulos, de modo que seja possível a execução independente de cada módulo, utilizando a mesma área de memória. A esta técnica dá-se o nome de segmentação ou overlay. Consideremos um programa que tenha três módulos: um principal, um de cadastramento e outro de impressão, sendo os módulos de cadastramento e impressão independentes. A independência 81 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS significa que quando um módulo estiver na memória para execução, o outro não necessariamente precisa estar presente.O módulo principal é comum aos outros dois, logo, precisa estar na memória durante todo o tempo da execução do programa. Na figura a seguir, a memória é insuficiente para armazenar todo o programa, que totaliza 9 KB. A técnica de overlay utiliza uma área de memória comum para armazenar o módulo principal do programa e uma outra área na mesma memória, chamada área de overlay, que será compartilhada entre os módulos de cadastramento e impressão. Assim, sempre que um dos módulos for referenciado no módulo principal, o sistema o carregará da memória secundária para a área de overlay, sobrepondo o módulo antigo na memória. Memória Principal 2 KB 3 KB 4 KB Sistema Operacional Cadastramento Módulo Principal Área de Overlay 4 KB Impressão 2 KB 1 KB Área livre 2 KB A definição das áreas de overlay é função do programador, através de comandos específicos da linguagem de programação utilizada. A grande vantagem da utilização desta técnica consiste em se poder executar programas maiores do que a memória física disponível. Alocação Particionada Estática Os sistemas operacionais evoluíram no sentido de proporcionar melhor aproveitamento dos recursos disponíveis. Nos sistemas monoprogramáveis o processador permanece grande parte do tempo ocioso e a memória principal é sub-utilizada. Os sistemas multiprogramáveis já são muito mais eficientes no uso do processador, necessitando que vários processos estejam na memória principal ao mesmo tempo e que novas formas de gerência de memória sejam implementadas. Nos primeiros sistemas multiprogramáveis a memória era dividida em blocos de tamanho fixo, chamados partições.O tamanho dessas partições, estabelecido em tempo de inicialização do sistema, era definido em função do tamanho dos programas que executariam no ambiente.Sempre que fosse necessária a alteração do tamanho de uma partição, o sistema deveria ser inicializado novamente com uma nova configuração. Sistema Operacional Partição 1 2 KB 82 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Partição 2 5 KB Partição 3 8 KB Inicialmente, os programas só podiam ser carregados e executados em apenas uma partição específica, mesmo que as outras estivessem disponíveis. Esta limitação se devia aos compiladores e linkeditores, que geravam apenas código absoluto. No código absoluto, todas as referências a endereços no programa são posições físicas na memória, ou seja, o programa só poderia ser carregado a partir do endereço de memória especificado no seu próprio código. A esse tipo de alocação de memória chamou-se alocação particionada estática absoluta. Coma evolução dos compiladores, linkeditores, montadores e loaders, o código gerado deixou de ser absoluto e passou a ser relocável . No código relocável, todas as referências a endereços no programa são relativas ao início do código e não a endereços fixos na memória. Desta forma, os programas puderam ser alocados em qualquer partição livre, independente do endereço inicial e da partição para a qual o código foi criado. A esse tipo de alocação deu-se o nome de alocação particionada estática relocável. Tanto nos sistemas de alocação absoluta como nos de alocação relocável, os programas, normalmente, não ocupam totalmente as partições onde são alocados, deixando algum espaço livre dentro das partições. Este tipo de problema, decorrente do esquema de alocação fixa de partições, é chamado fragmentação interna. A figura a seguir mostra um gráfico representando o particionamento estático de uma memória e sua fragmentação interna. Memória Principal Sistema Operacional Programa C 1 KB Programa A 3 KB Fragmentação interna Programa E 5 KB Alocação particionada estática com fragmentação interna 83 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Alocação Particionada Dinâmica A alocação particionada estática deixou clara a necessidade de uma nova forma de gerência de memória principal, onde o problema da fragmentação interna fosse reduzido e, conseqüentemente, o grau de compartilhamento da memória aumentado. Na alocação particionada dinâmica, foi eliminado o conceito de partições de tamanho fixo. Nesse esquema, cada programa, ao ser carregado, utilizaria o espaço necessário à sua execução, tornando esse espaço a sua partição. Assim, como os programas utilizam apenas o espaço de que necessitam, no esquema de alocação particionada dinâmica o problema da fragmentação interna deixa de existir. Porém, com o término de alguns programas e o início de outros, passam a existir na memória blocos cada vez menores na memória, não permitindo o ingresso de novos programas. A este tipo de problema dá-se o nome de fragmentação externa. Para resolver o problema da fragmentação externa, os fabricantes tentaram duas soluções: reunião de todos os blocos livres adjacentes, formando uma grande área livre, que se transforma em uma nova partição; realocação de todas as partições ainda ocupadas para a parte inicial da memória, eliminando os blocos livres entre elas, formando uma grande área livre no final da memória, que podia ser distribuída entre os processos ainda por executar. A este tipo de compactação de espaços livres foi dado o nome de alocação particionada dinâmica com realocação. Estas soluções ajudaram a diminuir os problemas da fragmentação (tanto interna como externa), mas, devido á complexidade dos algoritmos, nem todos os sistemas operacionais as utilizaram. Estratégias de Alocação de Partição Os sistemas operacionais implementam basicamente três estratégias para determinar em qual área livre um programa será alocado para execução. Essas estratégias tentam evitar ou diminuir o problema da fragmentação. A melhor estratégia a ser adotada por um sistema depende de uma série de fatores, sendo o mais importante o tamanho dos programas executados no ambiente. Independentemente do algoritmo utilizado, o sistema possui uma lista das áreas livres, com endereço e tamanho de cada área. São estratégias de alocação: Best-fit: é escolhida a melhor partição, ou seja, aquela que deixa o menor espaço sem utilização. Uma grande desvantagem desta estratégia é que, como são alocados primeiramente as partições menores, deixando pequenos blocos, a fragmentação aparece mais rapidamente. Worst-fit: aloca o programa na pior partição, ou seja, aquela que deixa o maior espaço livre. Esta técnica, apesar de aproveitar primeiro as partições maiores, acaba deixando espaços livres grandes o suficiente para que outros programas utilizem esses espaços, permitindo que um número maior de processos se utilizem da memória, diminuindo ou retardando a fragmentação. First-fit: esta estratégia aloca o programa na primeira partição que o couber, independente do espaço livre que vai deixar. Das três estratégias, esta é a mais rápida, consumindo menos recursos do sistema. Swapping É uma técnica aplicada à gerência de memória que visa dar maior taxa de utilização à memória principal, melhorando seu compartilhamento. Visa também resolver o problema da falta de memória principal num sistema. 84 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS Toda vez que um programa precisa ser alocado para execução e não há espaço na memória principal, o sistema operacional escolhe entre os processos alocados que não tem previsão de utilizar a CPU nos próximos instantes (quase sempre entre aqueles que estão em interrupção de E/S ou no final da fila de pronto), e ―descarrega‖ este processo da memória para uma área especial em disco, chamada arquivo de swap, onde o processo fica armazenado temporariamente. Durante o tempo em que o processo fica em swap, o outro que necessitava de memória entra em execução ocupando o espaço deixado pelo que saiu. Pouco antes de chegar a vez do processo armazenado em swap utilizar a CPU, o sistema escolhe um outro processo para descarregar para swap e devolve o anterior da área de swap para a memória principal, para que este possa ser executado novamente. E vai trabalhando assim até que os processos vão terminando. O problema dessa técnica é que pode provocar um número excessivo de acesso à memória secundária (disco), levando o sistema a uma queda de desempenho. Memória Virtual Desde o início da informática, o tamanho dos programas vem superando a quantidade de memória disponível para abrigá-los. A solução usualmente adotada era dividir o programa em partes, chamados overlays. O overlay 0 começa a ser executado primeiro. Quando termina, o overlay seguinte é executado, e assim por diante. Alguns sistemas com overlay eram relativamente complexos, permitindo múltiplos overlays na memória por vez. Overlays eram mantidos em disco e permutados para a memória pelo sistema operacional. Overlays apresentavam um problema: a partição do programa era deixada a cargo do programa-dor. Um método que foi desenvolvido para deixar o particionamento do programa a cargo do sistema operacional veio a ser conhecido como memória virtual. A idéia básica é que a combinação do tamanho do programa, dados e pilha, pode exceder a quantia de memória física disponível. O sistema operacional mantém aquelas partes do programa correntemente em uso na memória principal e o resto no disco. Por exemplo, um programa de tamanho 10M bytes pode ser executado em uma máquina com 1M bytes de memória escolhendo-se cuidadosamente quais dos 1M será mantido na memória a cada instante, com pedaços do programa sendo permutados ent re disco e memória assim que forem necessários. Memória virtual pode também trabalhar em um sistema com multiprogramação. Por exemplo, oito programas de 1M podem ser alocados em partições de 256K n uma memória de 2M, com cada programa operando como se tivesse sua própria máquina de 256K. De fato, memória virtual e multiprogramação estão intimamente relacionadas. Enquanto u m programa está esperando que parte de seu espaço de endereçamento seja trazido à memória, o programa é bloqueado, aguardando E/S. Até que a operação de E/S seja completada, a CPU pode ser direcionada para outro processo. Paginação A maioria dos sistemas com memória virtual usa uma técnica chamada paginação . Em qualquer computador existe certo conjunto de endereços de memória que programas podem referenciar. Quando um programa usa uma instrução como MOVE REG,1000, ele está movendo o conteúdo do endereço de memória 1000 para o registrador REG (ou vice versa, dependendo do computador). Endereços podem ser gerados usando indexação, registradores base, registradores de segmento, dentre outras maneiras. Estes endereços gerados pelos programas são chamados endereços virtuais e formam o espaço virtual de endereçamento do processo. Em computadores sem memória vitual, o endereço 85 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS virtual é colocado diretamente no barramento de memória e causa uma palavra da memória física com mesmo endereço ser lida ou escrita. Quando memória virtual é usada, os endereços de memória não vão diretamente para o barramento de memória. Ao invés disso, eles vão à unidade de gerenciamento de memória (Memory Management Unit, MMU), onde um hardware específico mapeia os endereços virtuais nos endereços da memória. Segmentação Paginação provê uma técnica para implementação de um grande32 espaço endereçável numa32 memória física limitada. Para algumas aplicações, um espaço endereçável bi-dimensional é mais conveniente. Idealmente, cada programa deve ter um número muito grande de segmentos (i.e. 2 = 4G), cada um consistindo de grande númeto de bytes (i.e. também2 ). Os primeiros 64K de segmentos podem ser reservados para procedimentos, dados, e pilhas, pertencentes ao programa em execução. Os segmentos restantes podem conter um arquivo por segmento, tal que processos possam diretamente endereçar todos seus arquivos, sem ter que abrí-los e usar primitivas especiais de E/S para lê-los e escrevê-los. Cada arquivo cresce ou reduz-se completamente, independentemente dos outros nesta disposição, com cada byte da memória sendo endereçado por um par (segment, offset). Algoritmos de Troca de Página Quando uma falta de página ocorre, o sistema operacional tem que escolher uma página para remover da memória a fim de dar lugar à que será trazida do disco . Se a página a ser removida foi modificada enquanto estava na memória, ela deve ser reescrita no disco para manter a cópia em disco atualizada. Se, todavia, a página não tiver sido alterada, a cópia do disco já está atualizada, não sendo necessária sua reescrita. A página a ser lida é simplesmente superposta à página retirada. Apesar de ser possível escolher uma página aleatória para dar lugar à página em demanda, o desempenho do sistema é melhorado se for escolhida uma página pouco usada (referenciada). Se uma página muito usada é removida, ela provavelmente terá de ser trazida de volta em breve, resultando um esforço adicional. Algoritmos eficientes de troca de página visam minimizar este esforço. Troca Ótima de Página O melhor algoritmo de troca de páginas é fácil de descrever mas impossível de implementar. O algoritmo opera da seguinte maneira. No momento que ocorre uma falta de página, um certo conjunto de páginas está na memória. Uma dessas páginas será referenciada em muitas das próxima instruções (a página contendo a instrução). Outras páginas não serão referenciadas antes de 10, 100, ou talvez 1000 instruções. Cada página pode ser rotulada com o número de instruções que serão executadas antes que a página seja inicialmente referenciada. O algoritmo da página ótima simplesmente diz que a página com maior rótulo deve ser remo-vida, adiando-se o máximo possível a próxima falta de página. Troca da Página Não Recentemente Usada (NRU) Para permitir que o sistema operacional colete estatísticas sobre quais páginas estão sendo usadas e quais não estão, muitos computadores com memória virtual têm 2 bits associados à cada página. Um bit, R ou bit de referência, é ativado pel ohardware em qualquer leitura ou escrita de página. O outro bit, M ou bit de modificação, é ativado pelo hardware quando uma página é escrita (i.e., um byte é alterado/adicionado na página). É importante que estes bits sejam atualizados em qualquer referência 86 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS de memória, assim, é essencial que eles sejam ativados pelo hardware. Uma vez que um bit foi ativado, ele permanece ativado até que o sistema operacional o desative (por software). Troca da Página FIFO O algoritmo de paginação First-In-First-Out (FIFO) é similar ao NRU. O sistema operacional mantém uma lista de todas as páginas correntes na memória, sendo a página da cabeça da lista a mais velha e a página do fim a instalada mais recentemente. Em uma falta de página, a página da cabeça é removida e a nova página acrescentada no fim da lista. Uma simples modificação no FIFO para evitar o problema da retirada de uma página muito usada é examinar os bits R e M da página mais velha. Se a página pertencer a classe 0 (não referenciada, não modificada), ela é retirada, senão a próxima página mais v elha é examinada, e assim por diante. Se páginas da classe 0 não estão presentes na memória, então o algoritmo é repetido procurando por páginas da classe 1, 2 e 3. Troca da Página Menos Recentemente Usada (LRU) Uma boa aproximação para o algoritmo ótimo é baseada em uma observação comum que as páginas muito usadas nas últimas instruções, provavelmente o serão nas próximas instruções. Da mesma forma, páginas que não têm sido usadas por um longo tempo provavelmente continuarão sem uso. Esta observação sugere um algoritmo realizável: quando ocorre uma falta de página, retira-se a página que não tem sido usada por um tempo longo. Esta estratégia é chamada de Menos Recentemente Usada (Least Recently Used - LRU). Algoritmos de substituição de páginas O maior problema na gerência de memória virtual por paginação não é decidir quais páginas carregar para a memória real, mas sim quais páginas liberar. Quando há a necessidade de carregar uma página, o sistema deve selecionar entre as diversas páginas alocadas na memória qual delas deverá ser liberada pelo processo. Os algoritmos de substituição de páginas têm o objetivo de selecionar os frames que tenham as menores chances de serem referenciados num futuro próximo. Caso contrário, o frame poderia retornar diversas vezes para a memória real, provocando excesso de page faults. São algoritmos de substituição de páginas: algoritmo ótimo: impossível de ser implementado, pois o processador não consegue prever com segurança qual frame não será mais referenciado durante a execução do programa. Tal fato deve-se à lógica do programa e aos dados que ele manipula, desconhecidos pelo processador. Algoritmo aleatório: escolhe qualquer página, entre as alocadas na memória, para fazer a substituição. Em função de sua baixa eficiência, este algoritmo não muito utilizado, embora consuma poucos recursos do sistema. Algoritmo FIFO (first in, first out): escolhe a página que está há mais tempo na memória principal para fazer a troca. É um algoritmo de simples implementação, mas corre o risco de retirar uma página que, embora tenha sido carregada há mais tempo, esteja sendo muito utilizada. Por essa razão não é muito usado. Algoritmo LFU (least frequently used): elege a página menos freqüentemente usada para efetuar a troca. Através de um contador, armazenado na tabela de endereçamento de páginas, mo 87 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS sistema identifica quantas referências cada página teve e utiliza esta informação para escolher a página. Algoritmo LRU (least recently used): elege a página menos recentemente usada para fazer a troca. O sistema mantém na tabela de endereçamento de páginas um campo onde são armazenadas a data e a hora da última referência de cada página, e com base nestas informações faz a seleção. Algoritmo NRU (not recently used): elege a página menos recentemente usada para efetuar a troca. O sistema exclui da decisão a página mais recente e escolhe entre as outras, pelo método FIFO, qual página deve sair. Gerência de Sistemas de Arquivos Estrutura de Diretórios É como o Sistema organiza logicamente os arquivos. Contém entradas associadas aos arquivos, com as informações de localização, nome, organização e outros atributos: Nível único: é a implementação mais simples de uma estrutura de diretórios, onde existe um único diretório contendo todos os arquivos do disco. É muito limitado, não permitindo a criação de arquivos com o mesmo nome. Diretório pessoal: Evolução do modelo anterior, permite a cada usuário ter ser ―diretório‖ particular, sem a preocupação de conhecer os outros arquivos do disco. Neste modelo há um diretório ―master‖ que indexa todos os diretórios particulares dos usuários, provendo o acesso a cada um. Múltiplos níveis (ÁRVORE): É o modelo utilizado hoje em dia em quase todos os Sistemas Operacionais. Nesta modalidade cada usuário pode criar vários níveis de diretórios (ou subdiretórios), sendo que cada diretório pode conter arquivos e sub-diretórios. O número de níveis possíveis depende do Sistema Operacional. SISTEMA DE ARQUIVOS A parte mais visível de um sistema operacional é o seu sistema de arquivos. Programas aplicativos utilizam o sistema de arquivos (via chamadas de sistema) para criar, ler, gravar e remover arquivos. Usuários utilizam interativamente o sistema de arquivos (via shell) para listar, alterar propriedades e remover arquivos. A conveniência e facilidade de uso de um Sistema operacional é fortemente determinada pela interface, estrutura e confiabilidade de s eu sistema de arquivos. Interface do Sistema de Arquivos Do ponto de vista do usuário, o aspecto mais importante do sistema de arquivos é como ele se apresenta, isto é, o que constitui um arquivo, como os arquivos são identificados e protegidos, que operações são permitidas sobre os arquivos, e assim por diante. Fundamentos Básicos A maior parte dos sistemas operacionais trazem a seguinte proposta para armazenamento de informação: permitir aos usuários definir objetos chamados arquivos, que podem armazenar programas, dados, ou qualquer outra informação. Estes arquivos não são parte endereçável de nenhum processo e o sistema operacional provê operações especiais (i.e., chamadas de sistema) para criar, destruir, ler, atualizar e proteger arquivos. Todos os sistemas operacionais visam uma independência dos dispositivos de armazenamento, permitindo acessar um arquivo sem especificar em qual dispositivo o mesmo se encontra fisicamente armazenado. Um programa que lê um arquivo de entrada e escreve um arquivo saída deve ser capaz 88 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS de operar com arquivos armazenados em quaisquer dispositivos, sem necessidade de um código especial para explicitar o tipo de periférico. Alguns sistemas operacionais provêem maior independência dos dispositivos de armazenamento que outros. No UNIX, por exemplo, um sistema de arquivos pode ser montado em qualquer dispositivo de armazenamento, permitindo que qualquer arquivo seja acessado pelo seu nome (path name), sem considerar o dispositivo físico. No MS-DOS, por outro lado, o usuário deve especificar em qual dispositivo cada arquivo se encontra (exceto quando um dispositivo é default e for omitido). Assim, se o dispositivo default for o drive C, para executar um programa localizado no drive A com arquivos de entrada e saída no drive B, cada um deles deverá ser especificado juntamente com o nome do aquivo: A:programa < B:entrada > B:saida A maior parte dos sistemas operacionais suportam vários tipos de arquivos. O UNIX, por exemplo, mantém arquivos regulares, diretórios e arquivos especiais. Arquivos regulares contém dados e programas do usuário. Diretórios permitem identificar arquivos através de nomes simbólicos (i.e. sequência de caracteres ASCII). Arquivos especiais são usados para especificar periféricos tais como terminais, impressoras, unidades de fita, etc. Assim podemos digitar cp abc /dev/tty para copiar um arquivo abc para o terminal (arquivo especial /dev/tty). Em muitos sistemas, arquivos regulares são subdivididos em diferentes tipos em função de sua utilização. Os tipos são identificados pelos nomes com que os arquivos regulares terminam. Por exemplo, ARQUIVO.PAS - Programa fonte em Pascal ARQUIVO.FTN - Programa fonte em Fortran ARQUIVO.BAS - Programa fonte em Basic ARQUIVO.OBJ - Arquivo objeto ARQUIVO.BIN - Programa binario executável ARQUIVO.LIB - Biblioteca dos arquivos .OBJ usados pelo linker ARQUIVO.TXT - Texto de entrada para formatação de programa ARQUIVO.DAT - Arquivos de dados Diretórios Para organizar os arquivos, o sistema de arquivos provê diretórios, os quais em muitos casos são também arquivos. Um diretório contém tipicamente um número de registros, um por arquivo. Sistemas primitivos admitiam um único diretório compartilhado por todos os usuários, ou um único diretório por usuário. Os sistemas operacionais modernos permitem um número arbitrário de diretórios por usuário (via de regra, formando uma hierarquia). Quando o sistema de arquivos é organizado como uma árvore de diretórios, algum meio se faz necessário para especificar nomes de arquivos. Dois métodos são comumente empregados. No primeiro método, cada arquivo é identificado pela sequência de diretórios desde o diretório raiz até o arquivo (caminho absoluto). Como um exemplo, o caminho /usr/mfm/mailbox significa que o diretório raiz (/) contém o subdiretório usr, o qual contém o subdiretório mfm, que por sua vez contém o arquivo mailbox. Nomes absolutos para caminhos sempre começam na raiz e são únicos. Uma outra forma de especificar nomes de arquivos é através de seu caminho relativo. É usado em conjunto com o conceito de diretório de trabalho (ou diretório corrente). Um usuário pode designar 89 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS um diretório como diretório corrente. Neste caso, todos os c aminhos são referenciados a partir do diretório corrente. Se o diretório corrente for é /usr/mfm, então o arquivo cujo caminho absoluto é/usr/mfm/mailbox pode ser referenciado simplesmente como mailbox. Confiabilidade do Sistema de Arquivos Blocos Defeituosos Discos frequentemente apresentam blocos defeituosos (bad blocks), isto é, blocos onde a escrita e/ou leitura é impossibilitada. Duas soluções para o problema de blocos defeituosos são empregadas, uma em hardware e outra em software. A solução em hardware consiste em dedicar um setor no disco para a lista de blocos defeituosos. Quando o controlador do disco é iniciado, este lê a lista de blocos defeituosos e escolhe blocos sobressalentes para substituí-los. São feitas então indireções dos blocos defeituosos para os blocos sobressalentes. Daí por diante, qualquer operação envolvendo um bloco defeituoso terá efeito em seu respectivo bloco sobressalente. A solução em software requer que o usuário informe (ou que o sistema de arquivos detecte) os blocos defeituosos. Estes blocos são armazenados num arqui vo, acessado quando da construção da lista de blocos livre. Conhecendo os blocos defeituosos, o sistema operacional não os incorpora na lista de blocos livre, eliminando assim sua ocorrência futura em arquivos de dados. Consistência do Sistema de Arquivos Outro tópico envolvendo confiabilidade é a consistência do sistema de arquivos. Muitos sistemas de arquivos lêem blocos, modifica-os, e os regrava mais tarde. Se o sistema falha antes que todos os blocos modificados forem escritos no disco, o sistema de arquivos assume um estado inconsistente. Este problema é especialmente crítico se alguns dos blocos que não foram escritos, são blocos de inodes, blocos de diretório, ou blocos contendo a lista de blocos livre. Para verificar a consistência do sistema de arquivos, muitos sistemas operacionais utilizam programas utilitários desenvolvidos para este fim. Este programa é executado sempre que o sistema é iniciado, particularmente depois de um desligamento adrúpto. A seguir é descrito como tal utilitário opera no UNIX. O controle de consistência se dá em dois níveis: blocos e arquivos. Para controle de consistência a nível de bloco, o utilitário constrói uma tabela com dois contadores por bloco, ambos iniciados em 0. O primeiro contador rastreia quantas vezes o bloco aparece no arquivo; o segundo registra com que frequência ele aparece na lista de blocos livre. O utilitário lê todos os inodes. Começando de um inode, é possível construir uma lista de todos os números de blocos usados no correspondente arquivo. Assim que cada número de bloco é lido, seu respectivo contador na primeira tabela é incrementado. A seguir, é examinada a lista de blocos livre rastreando todos os blocos que não estão em uso. Cada ocorrência de um bloco na lista de blocos livre resulta no incremento do respectivo contador na segunda tabela. Se o sistema de arquivo for consistente, cada bloco terá o valor 1 na primeira tabela ou na segunda tabela. Contudo, em caso de falha, pode detectar-se blocos que não ocorrem em nenhuma das tabelas (blocos perdidos). Embora blocos perdidos não causem um dan o real, eles desperdiçam espaço, reduzindo assim a capacidade do disco. A solução para blocos perdidos é direta: o verificador do sistema de arquivos acrescenta-os na lista de blocos livre. Outra situação possível de ocorrer é a repetição de blocos na lista de blocos livre. A solução neste caso também é simples: reconstruir a lista de blocos livre, limitando-se as duplicações. O mais grave é a ocorrência do mesmo bloco de dados em dois ou mais arquivos. Se cada um desses 90 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS arquivos for removido, o bloco duplicado será posto na lista de blocos livre, chegando-se em uma situação em que o mesmo bloco está, ambiguamente, em uso e livre ao mesmo tempo. Se ambos os arquivos forem removidos, o bloco será adicionado na lista de blocos livre duas vezes. A ação apropriada do utilitário é alocar um bloco livre, copiar o conteúdo do bloco duplicado nele, e inserir a cópia em um dos arquivos. Desde modo, a infor mação dos arquivos não é alterada (embora certamente incorreta para um dos arquivos), mas a estrutura do sistema de arquivos é, pelo menos, consistente. O erro será informado para permitir ao usuário examinar a falha. Ainda para verificar se cada bloco é contado corretamente, o utilitário também examina o sistema de diretórios (consistência a nível de arquivos). Neste caso, é usada uma tabela de contadores por arquivos (não por blocos, como anteriormente). A verific ação começa no diretório raiz e, recursivamente, desce a árvore inspecionando cada diretório no sistema de arquivos. Para cada arquivo encontrado, incrementa-se o contador para o seu respectivo inode. Quando toda a árvore de diretórios é percorrida, tem-se uma lista indexada pelo número do inode, descrevendo quantos diretórios apontam para aquele inode. O utilitário então compara esses valores com os contadores dos inodes. Em um sistema de arquivos consistente, ambos contadores coincidirão. Contudo, dois tipos de erros podem ocorrer: o contador do inode pode ser maior ou menor que o da lista do utilitário. Se a contagem no inode for maior que o número de registros do diretório, então mesmo se todos os arquivos forem removidos dos diretórios, o contador aind será diferente de 0 e o inode não será liberado. Este erro não é catastrófico, mas consome espaço no disco com arquivos que não estão em nenhum dos diretórios. O contador de conexões do inode deve ser corrigido através da atribuição do valor obtido pelo utilitário. Outro erro (potencialmente catastrófico) ocorre quando o contador do inode é menor que o encontrado pelo utilitário. A medida que os arquivos que apontam para o inode vão sendo removidos, o contador do inode pode chegar a zero, momento que o inode e seus respectivos blocos são liberados. Esta ação resultará em um dos diretórios apontando para um inode não mais em uso, cujos blocos podem rapidamente ser atribuidos a outros arquivos. Novamente, a solução é forçar o contador do inode para o número real de registros do diretório (obtidas pelo utilitário). Estas duas operações, verificar blocos e verificar diretório s, são frequentemente integradas por razães de eficiência (i.e., uma única passagem sobre osinodes é requerida). Outros controles heurísticos são também possíveis. Por exemplo, diretórios têm um formato definido, com um número inodes e nomes ASCII. Se um númeroinode for maior que o número deinodes no disco, o diretório encontra-se num estado inconsistente. Desempenho do Sistema de Arquivos Um acesso a disco é muito mais lento que um acesso a memória. Ler uma palavra da memória leva tipicamente algumas centenas de nanosegundos. Ler um bloco do disco requer dezenas de milisegundos, um fator 100.000 vezes mais lento. Como resultado, muitos sistemas de arquivos têm sido projetados para reduzir o número necessário de acessos disco. A técnica mais comum para reduzir o acesso a disco é a block cache ou buffer cache. Neste contexto, uma cache é uma coleção de blocos que pertencem logicamente ao disco, mas são mantidos na memória por razões de desempenho. Vários algoritmos podem ser usados para gerenciar ocache, mas o mais comum é o que verifica todas as requisições de leitura para ver se o bloco referido e stá nacache. Se estiver, a requisição de leitura pode ser satisfeita sem acesso a disco. Se o bloco não estiver na cache, ele é inicialmente lido para a 91 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS cache, e então copiado para a área do processo que requisitou o acesso. Requisições subsequentes do mesmo bloco podem ser satisfeitas através da cache. Quando um bloco tem que ser carregado para uma cache cheia, algum bloco terá que ser removido e reescrito no disco, caso tenha sido modificado desde o insta nte em que foi instalado na cache. Esta situação é muito parecida com a paginação, e todos os algorit mos usuais de paginação, tal como o ―menos recentemente usado‖ (LRU) podem ser aplicados neste contexto. Se um bloco for essencial para a consistência do sistema de arquivos (basicamente tudo, exceto blocos de dados), e foi modificado na cache, é necessário que o mesmo seja escrito no disco imediatamente. Escrevendo blocos críticos rapidamente no disco, reduzimos a probabilidade que falhas danifiquem o sistema de arquivos. Até mesmo com estas medidas para manter a integridade do sistema de arquivos, é indesejável manter blocos de dados na cache durante muito tempo antes que sejam descarregados em disco. Os sistemas de arquivos adotam duas estratégias para tal. No UNIX, a chamada de sistema sync, força com que todos os blocos modificados sejam gravados em disco im ediatamente. Quando o sistema é iniciado, um programa, usualmente chamado update, é ativado. De 30 em 30 segundos, a atualização da cache é estabelecida. Como resultado, na pior hipótese, perde-se os blocos gravados nos últimos 30 segundos em caso de uma pane. A solução do MS-DOS é gravar todo bloco modificado para o disco tão logo ele tenha sido escrito. Caches nas quais blocos modificados são reescritos imediatamente n o disco são chamadas caches de escrita direta. Elas requerem muito mais E/S de disco que caches de escrita não direta. A diferença entre estas duas técnicas pode ser vista quando um programa escreve num buffer de 1K, caracter por caracter. O UNIX coleta todos os caracteres da cache, e escreve o bloco de uma vez em 30 segundos, ou quando o bloco for removido da cache. O MS-DOS faz acesso a disco para cada um dos caracteres escritos. Naturalmente, muitos programas fazem ―bufferização‖ interna, procedendo gravaçõe s em disco apenas quando existir uma determinada quantidade de bytes pendentes. A estratégia adotada pelo MS-DOS foi influenciada pela garantia que a remoção de um disco flexível de sua unidade nã o causa perda de dados. No UNIX, é necessária uma chamadasync antes da remoção de qualquer meio de armazenamento (ou da par ada programada do sistema). Cache não é a única maneira de aumentar o desempenho do sistema de arquivos. Uma outra maneira é reduzir a quantidade de movimentos do braço do disco, colocando blocos que estão sendo acessados em sequência, preferencialmente em um mesmo cilindro. Quando um arquivo é escrito, o sistema de arquivos aloca os blocos um por vez, a medida do necessário. Se os blocos livre estiverem gravados em um mapa de bits, e o mapa de bits inteiro está na memória principal, é fácil escolher um bloco que está mais perto do bloco anterior. Com uma lista de blocos livre, parte da qual está no disco, é mais difícil alocar blocos próximos. Entretanto, com uma lista de blocos livre alguns agrupamentos de blocos podem ser feitos. O artifício é manter a trilha do disco armazenada não em blocos, mais em grupos consecutivos de blocos. Se uma trilha consistir de 64 setores de 512 bytes, o sistema pode usar blocos de 1K bytes (2 setores), porém alocando espaço no disco em unidades de 2 blocos (4 setores). Isto não é o mesmo que ter um bloco de 2K, posto que na cache ainda se usa blocos de 1K com transferência para disco também de 1K. Entretanto, a leitura sequencial reduz o número de busca de um fator de 2, melhorando consideravelmente o desempenho. Outra variante é fazer uso do posicionamento rotacional. Quando se alocam blocos, o sistema atenta 92 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS para colocar blocos consecutivos de um arquivo no mesmo cilindro, mas intercalados. Deste modo, se um disco tiver um tempo de rotação de 16.67 mseg e 4 mse g são necessários para o processo do usuário requerer e acessar um bloco do disco, cada bloco deve ser colocado em ao menos um quarto da distância do seu antecessor. Um outro agravante no desempenho dos sistemas que usam inodes, ou algo similar, é que para ler até mesmo um pequeno arquivo, seja necessário 2 acessoson disco: um para o inode e outro para o bloco. Caso todos os inodes estejam próximos do início do disco, distância média entre o inode estará em torno da metade do número de cilindros, o que exigeongasl buscas. Melhor alternativa é instalar osinodes no meio do disco, reduzindo a média de busca entre o inode e o primeiro bloco de um fator de 2. Uma outra idéia consiste emdividir o disco em grupos de cilindros, cada qual com os seus próprios inodes, blocos, e lista de blocos livre. Quando se cria um novo arquivo, qualquer inode pode ser escolhido, mas tendo-se o cuidado de achar um bloco no mesmo grupo de cilindros onde o inode está. Caso nenhum bloco esteja disponível, escolhe-se um bloco do cilindro mais próximo. Sistemas de alocação de arquivos FAT: sistema criado no MS-DOS e depois utilizado no Windows. Usa listas encadeadas, tem um limite de área utilizável em partições de 2 GB, caracteriza-se por um baixo desempenho no acesso e armazenamento. FAT32: igual ao FAT no que diz respeito a organização e desempenho, mas pode trabalhar com partições de até 2TB. NTFS: NT File System, original da plataforma Windows NT/2000/XP. Opera com uma estrutura em árvore binária, oferecendo alto grau de segurança e desempenho: nomes de arquivo com até 255 caracteres, podendo conter maiúsculas, minúsculas e espaços em branco; dispensa ferramentas de recuperação de erros; bom sistema de proteção de arquivos; criptografia; suporta discos de até 264 bytes. UNIX: Usa diretório hierárquico, com um raiz e outros diretórios subordinados. Neste Sistema Operacional todos os arquivos são considerados apenas como uma ―seqüência‖ de bytes, sem significado para o Sistema. É responsabilidade da aplicação controlar os métodos de acesso aos arquivos. O UNIX utiliza também alguns diretórios padronizados, de exclusividade do Sistema. ENTRADA/SAÍDA Uma das principais funções do sistema operacional é controlar todos os dispositivos de entrada/saída (E/S) do computador, emitindo comandos para os dispositivos, atendendo interrupções e manipulando erros. Deve também prover uma interface entre os dispositivos e o resto do sistema, que seja simples e fácil de usar (se possível, a interface devser a mesma para todos os dispositivos). O código de entrada/saída representa uma fração significativa do total do sistema operacional. A forma como o sistema operacional gerencia E/S é o objeto deste capítulo. Dispositivos de E/S Dispositivos de E/S podem ser grosseiramente divididos em duas categorias: dispositivos de bloco e 93 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS dispositivos de caracter. Um dispositivo de bloco armazena informações em blocos de t amanho fixo, cada um com seu próprio endereço. Tamanhos comuns de blocos estão na faixa de 128 bytes a 1024 bytes. A propriedade essencial dos dispositivos de bloco é que é possível ler ou escrever cada bloco independentemente de todos os outros. Em outras palavras, em qualquer instante, o programa pode ler ou escrever qualquer um dos blocos. Discos são dispositivos de bloco. O outro tipo de dispositivo de E/S, o de caracter, libera ou aceita uma fila de caracteres sem definir nenhuma estrutura de bloco. Ele não é endereçável e não aceita operações de busca. Terminais, impressoras, leitoras ótica e outros dispositivos que não trabalham como os discos são exemplos de dispositivos de caracter. Este esquema de classificação não é perfeito. Alguns dispositivos não são enquadrados nele. Relógios, por exemplo, não são endereçáveis por bloco. Nem geram ou aceitam filas de caracteres. Tudo o que fazem é gerar interrupções em intervalos regulares. Contudo, este modelo é geral o suficiente para ser usado como base na construção de um sistema operacional com bom nível de independência dos dispositivos de E/S. O sistema de arquivo, por exemplo, negocia apenas com dispositivos de blocos abstratos, e deixa a parte dependente do dispositivo para o software de mais baixo nível, chamado acionadores de dispositivos (device drivers). Controladores de Dispositivos Unidades de E/S consistem tipicamente de componentes mecânicos e eletrônicos. É frequente a separação das duas porções para se obter um projeto mais geral e modular. O componente eletrônico é chamado decontrolador do dispositivo (device controller ou adapter). Em mini e microcomputadores, ele normalmente toma forma de um circuito impresso que pode ser inserido no computador. O componente mecânico é o dispositivo propriamente dito. O cartão do controlador normalmente tem um conector, no qual um cabo condutor do próprio dispositivo pode ser conectado. Muitos controladores podem manusear dois ou mais dispositivos do mesmo tipo. A distinção entre dispositivo e controlador deve ser ressaltada, já que o sistema operacional vê o controlador, não com o dispositivo. Normalmente, minicomputadores e microcomputadores usam um barramento único para comunicação entre CPU e os controladores. Mainframes frequentemente usam um modelo diferente, no qual múltiplosbarramentos e computadores especializados de E/S, chamados canais de E/S, aliviam parte da carga da CPU. A interface entre o controlador e o dispositivo é, via de regra, uma interface de baixo nível. O disco, por exemplo, pode ser formatado com 8 setores de 512 bytes por trilha. O que realmente sai do driver, entretanto, é uma lista serial de bits, partindo com um preâmbulo, depois os 4096 bits no setor, e finalmente o checksum ou o código de correção de erro. O preâmbulo é escrito quando o disco é formatado, e contém o número de cilindros e de setores, o tamanho do setor, e outros dados. A tarefa do controlador é converter a lista serial de bits em um bloco de bytes e realizar alguma correção de erro necessária. O bloco de bytes é tipicamente primeiro montado, bit por bit, em um buffer mantido no controlador. Após o checksum ter sido verificado e o bloco declarado livre de erro, ele pode então ser copiado para a memória principal. Cada controlador tem alguns poucos registradores que são usados para comunicação com a CPU. Em alguns computadores estes registradores são parte do espaço de endereçamento regular. A tabela mostra os endereços de E/S e os vetores de interrupção alocados para alguns dos controladores do IBM PC. A atribuição de endereços de E/S para dispositivos é feita por um decodificador lógico associado ao controlador. Alguns IBM PC-compatíveis usam diferentes endereços de E/S. 94 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS dispositivo endereço E/S vetor int. relógio 040 - 043 8 teclado 060 - 063 9 porta serial secundária 2F8 - 2FF 11 disco rígido 320 - 32F 13 impressora 378 - 37F 15 vídeo monocromático 380 - 3BF vídeo colorido 3D0 - 3DF disco flexível 3F0 - 3F7 14 porta serial primária 3F8 - 3FF 12 O sistema operacional realiza E/S escrevendo comandos nos registradores dos controladores. O controlador de disquete do IBM PC, por exemplo, aceita 15 diferentes comandos, tais como read, write, seek, format, e recalibrate. Muitos dos comandos têm parâmetros, os quais são também carregados nos registradores do controlador. Quando um comando é aceito, a CPU pode abandonar o controlador atender a outra tarefa. Quando completado, o controlador causa uma interrupção com o objetivo de permitir que o sistema operacional tome o controle da CPU e teste o resultado da operação. A CPU obtém o resultado e o status do dispositivo pela leitura de um ou mais bytes de informação nos registradores do controlador. Manipuladores de Interrupções Interrupções são eventos complicados de se tratar. Elas devem ser isoladas de modo que apenas uma pequena parte do sistema operacional as manipule. Um meio para isolá-las é bloquear os processos aguardando operações de E/S até que uma interrupção anuncie que a operação se completou. Quando a interrupção acontece, a rotina de tratamento daquela interrupção libera o processo bloqueado. Em alguns sistemas isto é conseguido fazendo-se um UP sobre um semáforo. Em outros, ele fará um SIGNAL sobre a variável de condição no monitor. E ainda em outros, uma mensagem é enviada ao processo bloqueado. Em todos os casos o efeito da interrupção é que o processo que estava previamente bloqueado deverá agora estar habilitado para execução. 95 Associação Profissionalizante “Vereador Jandir Schincariol” APVJS BIBLIOGRAFIA www.unicamp.br www.ufrn.br www.microsoft.com.br www.babbo.com.br www.boadica.com.br www.lunixit.com.br Davis, William S., Sistemas Operacionais - Uma Visão Sistemática, Ed. Campus, 1990. Machado, Francis B. e Maia, Luiz P., Introdução à Arquitetura de Sistemas Operacionais, Ed. LTC, 1994. Stallings, William, Operating Systems,Ed. Acmillan Publishing Company, 1992. Silberschatz, Abraham e Galvin, Peter B., Operating Systems Concepts, Ed. Addison-Wesley Publishing Company, 1994. Tanenbaum, Andrew S., Sistemas Operacionais Modernos, Ed. Campus, 1995. Tanenbaum, Andrew S., Organização Estruturada de Computadores, Ed. Prentice-Hall do Brasil, 1990. Tanenbaum, Andrew S., Sistemas Operacionais - Projeto e Implementação, Ed. Prentice-Hall do Brasil, 1987. Machado, Francis B. e Maia, Luiz P., Introdução à Arquitetura de Sistemas Operacionais, Ed. LTC, 1994. 96
