Apostila de: Gestão de Sistemas Operacionais – I ( G.S.O – I ) · G.S.O – I – Gestão de...

G.S.O – I – Gestão de Sistemas Operacionais I

Prof. Cássio M. Baraky

Email.: [email protected]

Apostila de:

Gestão de Sistemas Operacionais – I

( G.S.O – I )

Prof. Cássio Mendes Baraky Email: [email protected]

_Copyright (c) 2008 CÁSSIO MENDES BARAKY. É garantida a permissão para copiar, distribuir e/ou modificar este documento sob os termos da Licença de Documentação Livre GNU (GNU Free Documentation License), Versão 1.2 ou qualquer versão posterior publicada pela Free Software Foundation. A licença está disponível em http://www.gnu.org/licenses/gfdl.txt.




1 Conceitos Básicos do Computador ........................................................................ 4 2 As unidades de informação: bit e byte ................................................................... 6

2.1 Por que 1 Kb equivale a 1024 bytes? ............................................................. 6 3 Fases Históricas da Computação ........................................................................... 7

3.1 Primeira Fase (1945-1955) ............................................................................ 7 3.2 Segunda Fase (1956-1965) ............................................................................ 7 3.3 Terceira Fase (1966-1980)............................................................................. 9 3.4 Quarta Fase (1981-1990) ............................................................................. 10 3.5 Quinta Fase (1991- ) .................................................................................... 10 3.6 Tabela de Características de cada Fase......................................................... 12

4 Histórico dos sistemas operacionais..................................................................... 14 5 Sistemas Operacionais......................................................................................... 16

5.1 O que é um sistema operacional? ................................................................. 16 5.2 Tipos de sistemas operacionais .................................................................... 16

5.2.1 Sistema operacional em lote (Batch) .................................................... 16 5.2.2 Sistema de tempo compartilhado.......................................................... 16 5.2.3 Sistemas de computadores pessoais (Desktop) ..................................... 17 5.2.4 Sistemas paralelos................................................................................ 17 5.2.5 Sistema de tempo real .......................................................................... 17 5.2.6 Sistemas distribuídos ........................................................................... 18 5.2.7 Sistemas Multi-usuário ........................................................................ 18 5.2.8 Sistemas de servidor ............................................................................ 18 5.2.9 Sistemas embutidos (embarcados)........................................................ 19

5.3 Funcionalidades do sistema operacional ...................................................... 19 5.3.1 Gerência do processador ...................................................................... 19 5.3.2 Gerência de memória ........................................................................... 19 5.3.3 Gerência de dispositivos ...................................................................... 19 5.3.4 Gerência de arquivos ........................................................................... 20 5.3.5 Gerência de proteção ........................................................................... 20

5.4 Estrutura de um sistema operacional ............................................................ 21 5.4.1 Núcleo ................................................................................................. 21 5.4.2 Drivers................................................................................................. 22 5.4.3 Código de inicialização........................................................................ 22 5.4.4 Programas utilitários ............................................................................ 22

5.5 Gerência de tarefas ...................................................................................... 23 5.6 O conceito de tarefa..................................................................................... 23 5.7 A gerência de tarefas ................................................................................... 25

6 Sistema Operacional MS-DOS ............................................................................ 29 6.1 HISTÓRIA DO MS-DOS............................................................................ 29

6.1.1 O IBM PC............................................................................................ 29 6.2 Eecutando os comandos do MS-DOS .......................................................... 31

6.2.1 Comandos internos do MS-DOS ......................................................... 32 6.2.1.1 Comando DATE .............................................................................. 32 6.2.1.2 Comando TIME............................................................................... 32 6.2.1.3 Comando VER................................................................................. 32 6.2.1.4 Comando CLS ................................................................................. 33 6.2.1.5 Comando MEM ............................................................................... 33 6.2.1.6 Comando Dir ................................................................................... 34




6.2.1.7 Comando para mudar a unidade de trabalho ..................................... 35 6.2.1.8 Comandos de diretório ..................................................................... 36

6.2.1.8.1 Comando MKDIR ou MD.......................................................... 36 6.2.1.8.2 Comando CHDIR ou CD............................................................ 36 6.2.1.8.3 Comando RD ou RMDIR........................................................... 36

6.2.1.9 Comando TYPE............................................................................... 37 6.2.1.10 Comando MORE ......................................................................... 37 6.2.1.11 Comando COPY .......................................................................... 37

6.2.2 Comandos externos do MS-DOS ......................................................... 38 6.2.2.1 Comando DISKCOPY ..................................................................... 38 6.2.2.2 Comando XCOPY ........................................................................... 39 6.2.2.3 Comando ATTRIB........................................................................... 39 6.2.2.4 Comando TREE............................................................................... 39 6.2.2.5 Comando MOVE ............................................................................. 40

6.2.3 Formatando disquetes e Discos Rígidos, apagando arquivos, e diretórios com conteúdo dentro. .......................................................................................... 41

6.2.3.1 Comando FORMAT ........................................................................ 41 6.2.3.2 Comando DEL ou ERASE............................................................... 41 6.2.3.3 Comando TREE............................................................................... 42

7 Arquivo .BAT ( LOTE / BATCH)....................................................................... 43 7.1 Para que serve um arquivo .BAT?................................................................ 43 7.2 Comandos de arquivos .BAT....................................................................... 43

7.2.1 Comando ECHO.................................................................................. 43 7.2.2 Comando GOTO.................................................................................. 43 7.2.3 Comando CALL .................................................................................. 43 7.2.4 Comando START ................................................................................ 44 7.2.5 Comando choice [texto] [opções]......................................................... 44

8 Bibliografia ......................................................................................................... 45




1 Conceitos Básicos do Computador Um sistema computacional pode ser dividido em três componentes básicos e fundamentais, onde o funcionamento errado ou a falta de um destes três elementos pode acarretar uma falha neste sistema.

Um sistema computacional pode ser dividido em:

Hardware – Parte física do equipamento ( monitores, peças internas, teclado, mouse, impressoras e outros.

Software – A parte lógica de um sistema computacional que corresponde a todos os programas, aplicativos e sistemas instalados e ou utilizados em uma maquina. Ex. (Windows, Linux, PowerDVD, MS-Word e outros).

Peopleware – A expressão peopleware, ou usuários, pessoas que utilizam um sistema computacional, é utilizada para mostrar que em um sistema computacional o homem tem e sempre terá um papel muito importante.

O hardware ainda pode ser dividido em periféricos e componentes de processamento principal, onde os componentes de processamento principais estão agrupados dentro de uma caixa metálica muitas vezes chamada erroneamente de CPU, quando o nome correto seria gabinete, a CPU (processador) está dentro do gabinete acoplado a outros equipamentos que fazem parte deste centro de processamento de dados. Todos os outros hardwares acoplados a este gabinete são chamados de periféricos, assim temos como periféricos hardwares como: mouse, teclado, monitor, impressora, microfone, caixas de som, scaner e muitos outros.

O homem interage com a maquina, inserindo nela dados, aguardando seu processamento e esperando dentro de um curto espaço de tempo uma resposta para seu cálculos comando e outras entradas de dados possíveis.

Os periféricos e hardwares do computador, ainda podem ser divididos em quatro conjuntos de dispositivos sendo eles:

• Dispositivos de Entrada.

• Dispositivos de Processamento.

• Dispositivos de Saída.

• Dispositivos de Entrada e Saída.

Veja o organograma abaixo:




Dispositivos de entrada são todos os equipamentos periféricos ou não que nos dão a possibilidade de entrar com dados em um sistema computacional, como os principais dispositivos de entrada de dados temos: Teclado, mouse, microfone, Drive de CD-Rom e muitos outros.

Dispositivos de processamento são todos os dispositivos responsáveis pelos cálculos e pelo processamento das informações, sejam elas matemáticas, lógicas ou qualquer outro tipo. Quando falamos em dispositivos de processamento nos vem a cabeça um único dispositivo, o processador, realmente o processador e responsável por processar milhões de cálculos em poucos segundos ou frações do mesmo, mas ele não esta sozinho com o único dispositivo de processamento, para que ele possa exercer seu trabalho, dispositivos como, placa mãe, memória e placa de vídeo devem estar funcionando perfeitamente e se comunicando uns com os outros, outros dispositivos também muito importantes são os hardwares de armazenamento como discos rígidos, unidades de fita e placas de multimídia como placas de áudio, rede e outros estes dispositivos porem auxiliam no processamento mas uma maquina pode funcionar sem a presença obrigatória deles.

Os dispositivos de saída são todos aqueles que nos retornam uma resposta dos dados processados pela maquina, nos dispositivos de saída ou de entrega de dados da maquina para o usuário temos como principal o monitor de vídeo e a impressora, também temos como dispositivos de saída as caixas de som, tornos CNC, bordadeiras e escultores digitais entre outros.

OS dispositivos de entrada e saída são dispositivo que possibilitam tanto o carregamento do sistema computacional com informações ou seja a entrada de dados no sistema como a entrega de respostas ou simplesmente a copia de dados do sistema para unidades externas, os equipamentos de entrada e saída são muitos, começando pelo simples e já praticamente obsoleto Drive de disquete, passando pelos Drives de Gravadores de CD e DVD ate dispositivos USB como pendrives, MP3 Player, MP4 e vários outros dispasitivos.

Dispositivos de

Entrada

Dispositivos de

Processamento

Dispositivos de

Saída

Dispositivos de

Entrada e Saída




2 As unidades de informação: bit e byte Em Informática é muito importante considerar a capacidade de armazenamento, já que quando se faz algo no computador, trabalha-se com arquivos que podem ser guardados para uso posterior. Evidentemente, quando se armazena algo, isto ocupa um certo espaço de armazenamento.

Assim como a água é medida em litros ou o açúcar é medido em quilos, os dados de um computador são medidos em bits e bytes. Cada valor do código binário foi denominado "bit" (binary digit), que é a menor unidade de informação.

Cada conjunto de 8 bits forma o byte, o qual corresponde a um caracter, seguindo o código binário.

2.1 Por que 1 Kb equivale a 1024 bytes?

No caso do quilo e de outras medidas de nosso dia-a-dia, a estrutura numérica é construída sobre a base 10. O termo quilo representa a milhar constituída de alguma coisa. Nossa base de trabalho numérica, sendo 10, faz com que, quando a base é elevada à terceira potência, atinja a milhar exatamente com 1000 unidades.

Mas, quando falamos em bytes, grupos de bits, não estamos falando em base 10, mas sim em uma estrutura fundamentada no código binário, ou seja, na base 2, nos 2 modos que o computador detecta, geralmente chamados de 0 e 1.

Assim, quando queremos um quilo de bytes, temos que elevar essa base a algum número inteiro, até conseguir atingir a milhar.

Mas não há número inteiro possível que atinja exatamente o valor 1.000. Então, ao elevarmos a base 2 à décima potência, teremos 1024.

Com esse raciocínio agora podemos entender a seguinte tabela:

Unidade de medida Número de caracteres Espaço

1 byte 1 8 bits

1 Kilobyte (Kb) 1.024 1024 bytes

1 Megabyte (Mb) 1.048.576 1024 Kb

1 Gigabyte (Gb) 1.073.741.824 1024 Mb

1 Terabyte (Tb) 1,099511628 x e12 1024 Gb

Portanto, concluímos que, por exemplo, quando se diz que um disco rígido tem capacidade de armazenamento de 4,3 Gb, são armazenados aproximadamente 4 milhões e 500 mil caracteres.




3 Fases Históricas da Computação A evolução dos sistemas operacionais está, em grande parte, relacionada ao desenvolvimento de equipamentos cada vez mais velozes, compactos e de custos baixos, e à necessidade de aproveitamento e controle desses recursos.

Neste histórico dividimos essa evolução em fases, once destacamos, em cada uma, sues principals características de hardware, software, interação com o sistema e aspectos de conectividade.

3.1 Primeira Fase (1945-1955) No início da Segunda Guerra Mundial, surgiram os primeiros computadores digitais, formados por milhares de válvulas, que ocupavam areas enormes, sendo de funcionamento lento e duvidoso.

O ENIAC (Electronic Numerical Integrator and Computer) foi o primeiro computador digital de propósito geral. Criado pare a realização de cálculos balísticos, sue estrutura possuía 18 mil válvulas, 10 mil capacitores, 70 mil resistores e pesava 30 toneladas. Quando em operação, consumia cerca de 140 quilowatts e era capaz de realizar 5 mil adições por segundo.

Para trabalhar nessas máquinas, era necessário conhecer profundamente o funcionamento do hardware, pods a programação era feita em painéis, através de fios, utilizando linguagem de máquina.

Nessa fase, ainda não existia o conceito de sistema operacional. Outros computadores foram construídos nessa mesma época, como o EDVAC (Electronic Discrete Variable Automatic Computer) e o IAS (Princeton Institute for Advanced Studies), mas eram utilizados, praticamente, apenas nas universidades e nos órgãos militares.

Com o desenvolvimento da indústria de computadores, muitas empresas foram fundadas ou investiram no setor, como a Sperry e a IBM, o que levou a criação dos primeiros computadores pare aplicações comerciais. A primeira máquina fabricada com esse propósito e bem-sucedida foi o UNIVAC I (Universal Automatic Computer), criado especialmente pare o censo americano de 1950.

3.2 Segunda Fase (1956-1965) A criação do transistor e das memórias magnéticas contribui pare o enorme avanço dos computadores da época. O transistor permitiu o aumento da velocidade e da confiabilidade do processamento, e as memórias magnéticas permitiram o acesso mais rápido aos dados, major capacidade de armazenamento e computadores menores.

Com o surgimento das primeiras linguagens de programação, como Assembly e Fortran, os programas deixaram de ser feitos diretamente no hardware, o que facilitou enormemente o processo de desenvolvimento de programas.

Já não era mais possível conviver com tantos procedimentos manuais como os anteriores, que não permitiam o uso eficiente do computador e de seus recursos. Os primeiros sistemas operacionais surgiram, justamente, pare tentar automatizar as tarefas manuais




Inicialmente, os programas passaram a ser perfurados em cartões, que, submetidos a uma leitora, eram gravados em uma fita de entrada (Figura 4a). A fita, então, era lida pelo computador, que executava um programa de cada vez, gravando o resultado do processamento em uma fita de saída (Figura 4b). Ao terminar de todos os programas, a fita de saída era lida e impressa (Figura 4c). A esse tipo de processamento, onde um lote (batch) de programas era submetido ao computador, deu-se o nome de processamento batch.

Pode não parecer um avanço, mas anteriormente os programas eram submetidos pelo operador, um a um, fazendo com que o processador ficasse ocioso entre a execução, ao de um programa e outro.

Com o processamento batch, um grupo de programas era submetido de uma só vez, o que diminuía o tempo existente entre a execução dos programas, permitindo, assim, melhor uso do processador.

Os sistemas operacionais passaram a ter seu próprio conjunto de rotinas pare operações de entrada/saída (Input/Output Control System—IOCS), que veio facilitar bastante o processo de programação. O IOCS eliminou a necessidade de os programadores desenvolverem sues próprias rotinas de leitura/gravação específicas para cada dispositivo periférico. Essa facilidade de comunicação criou o conceito de independência de dispositivos.

Importantes avanços, em nível de hardware, foram implementados no final dessa fase, principalmente na linha 7094 da IBM. Entre eles, destacamos o conceito de canal, que veio permitir a transferência de dados entre dispositivos de entrada/saída e memória principal de forma independente da UCP. Ainda nessa fase, destacamos os sistemas FMS (Fortran Monitor System) e IBSYS.




3.3 Terceira Fase (1966-1980) Através dos circuitos integrados (CIs) e, posteriormente, dos microprocessadores, foi possível viabilizar e difundir o uso de sistemas computacionais por empresas, devido a diminuição de seus custos de aquisição. Além disso, houve grande aumento do poder de processamento e diminuição no tamanho dos equipamentos.

Com base nessa nova tecnologia, a IBM lançou em 1964 a Série 360. Esse lançamento causou uma revolução na indústria de informática, pois introduzia uma linha (família) de computadores pequena, poderosa e, principalmente, compatível. Isso permitiu que uma empresa adquirisse um modelo mais simples e barato e, conforme sues necessidades, mudasse pare modelos com mais recursos, sem comprometer sues aplicações já existentes. Para essa série, foi desenvolvido o sistema operacional OS/360, que tentava atender todos os tipos de aplicações e periféricos. Apesar de todos os problemas desse equipamento e de seu tamanho físico, a Série 360 introduziu novas técnicas, utilizadas ate hoje.

Na mesma época, a DEC lançou a linha PDP-8, também revolucionária, pois apresentava uma linha de computadores de porte pequeno e baixo custo, se comparada aos mainframes ate então comercializados, criando um novo mercado, o de minicomputadores.

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 sue vez pare ser processado. A essa técnica de compartilhamento da memória principal e processador deu-se o nome de multiprogramação.

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, ate então puramente seqüencial. A essa técnica de submissão de programas chamou-se spooling, que, mais tarde, também viria a ser utilizada no processo de impressão.

Os sistemas operacionais, mesmo implementando o processamento batch e a multiprogramação, ao, ainda estavam limitados a processamentos que não exigiam comunicação com o usuário. Para permitir a interação rápida entre o usuário e o computador, foram adicionados terminais de vídeo e teclado (interação on-line).

A multiprogramação evoluiu preocupada em oferecer aos usuários tempos de respostas 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 timesharing (tempo compartilhado). Outro fato importante nessa fase foi o surgimento do sistema operacional Unix (1969). Concebido inicialmente em um minicomputador PDP-7, baseado no sistema MULTICS (Multiplexed Information and Computing Service), o Unix foi depois rescrito em uma linguagem de alto nível (linguagem C), tornando-se conhecido por sue portabilidade.

No final dessa fase, com a evolução dos microprocessadores, surgiram os primeiros microcomputadores, muito mais baratos que qualquer um dos computadores ate então comercializados.

Entre eles, destacamos os micros de 8 bits da Apple e o sistema operacional CP/M (Control Program Monitor).




3.4 Quarta Fase (1981-1990) A integração em large escala (Large Scale Integration-LSI) e a integração em muito large escala (Very Large Scale Integration-VLSI) levaram adiante o projeto de miniaturização e barateamento dos equipamentos. Os mini e superminicomputadores se firmaram no mercado e os microcomputadores ganharam um grande impulso.

Nesse quadro surgiram os microcomputadores PC (Personal Computer) de 16 bits da IBM e o sistema operacional DOS (Disk Operation System), criando a filosofia dos computadores pessoais. Na área dos minis e superminicomputadores ganharam impulso os sistemas multiusuário, com destaque pare os sistemas compatíveis com o Unix (Unix-like) e o VMS (Virtual Memory System) da DEC. Surgem as estações de trabalho (workstations) que, apesar de monousuárias, permitem que se executem diversas tarefas concorrentemente, criando o conceito de multitarefa.

No final dos anos 80, os computadores tiveram um grande avanço, decorrente de aplicações que exigiam um enorme volume de cálculos. Para acelerar o processamento, foram adicionados outros processadores, exigindo dos sistemas operacionais novos mecanismos de controle e sincronismo. Com o multiprocessamento, foi possível a execução de mais de um programa simultaneamente, ou ate de um mesmo programa por mais de um processador. Além de equipamentos com múltiplos processadores, foram introduzidos processadores vetoriais e técnicas de paralelismo em diferentes níveis, fazendo com que os computadores se tornassem ainda mais poderosos.

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, ate mesmo, fabricante.

Nesse contexto são desenvolvidos inúmeros protocolos de rede, alguns proprietários, como o DECnet da DEC e o SNA (System Network Architecture) da IBM, e outros de domínio público, como o TCP/IP e o CCITT X.25. Surgem as primeiras redes locals (Local Area Network—LANs) interligando pequenas áreas. Os softwares de rede passaram a estar intimamente relacionados ao sistema operacional e surgem os sistemas operacionais de rede.

3.5 Quinta Fase (1991- ) Grandes avanços em termos de hardware, software e telecomunicações podem ser esperados ate o final deste século. Essas mudanças são conseqüência da evolução das aplicações, que necessitam cada vez mais de capacidade de processamento e armazenamento de dados. Sistemas especialistas, sistemas multimídia, banco de dados distribuídos, inteligência artificial e redes neurais são apenas alguns exemplos da necessidade cada vez major.

A evolução da microeletrônica permitirá o desenvolvimento de processadores e memórias cada vez mais velozes e baratos, Além de dispositivos menores, mais rápidos e com major capacidade de armazenamento. Os componentes baseados em tecnologia VLSI (Very Large Scale Integration) evoluem rapidamente pare o ULSI (Ultra Large Scale Integration).

Os computadores da próxima geração têm de ser muito mais eficientes que os atuais, pare atender o volume cada vez major de processamento. Para isso, está ocorrendo uma mudança radical na filosofia de projeto de computadores. Arquiteturas paralelas, baseadas em organizações de multiprocessadores não convencionais, já se encontram em desenvolvimento em varies universidades e centros de pesquisa do mundo.




A evolução do hardware encadeará modificações profundas nas disciplines de programação pare fazer melhor uso das arquiteturas paralelas. Assim, novas linguagens e metodologias de programação concorrentes estão sendo desenvolvidas, em particular, fazendo uso extensivo de inteligência artificial e CAD (Computer-Aided Design).

O conceito de processamento distribuído será explorado nos sistemas operacionais, de forma que sues funções estejam espalhadas por vários processadores através de redes de computadores. Isso só será possível devido a redução, ao dos custos de comunicação e ao aumento na taxa de transmissão de dados.

A arquitetura cliente-servidor aplicada basicamente a redes locais passe a ser oferecida em redes distribuídas, permitindo que qualquer pessoa tenha acesso a todo tipo de informação, independentementede once esteja armazenada. Problemas de segurança, gerência e desempenho tornam-se fatores importantes relacionados ao sistema operacional e a rede.

A década de 90 foi definitiva pare a consolidação dos sistemas operacionais baseados em interfaces gráficas. Apesar da evolução da interface, a forma de interação com os computadores sofrerá, talvez, uma das modificações mais visíveis. Novas interfaces homem-máquina serão utilizadas, como linguagens naturais, sons e imagens, fazendo essa comunicação mais inteligente, simples e eficiente.

Os conceitos e implementações só vistos em sistemas considerados de grande porte estão sendo introduzidos na maioria dos sistemas desktop, como na família Windows da Microsoft, no Unix e no OS/2 da IBM.




3.6 Tabela de Características de cada Fase

Existe uma grande distância entre os circuitos eletrônicos e dispositivos de hardware e os programas aplicativos em software. Os circuitos são complexos, acessados através de interfaces de baixo nível (geralmente usando as portas e entrada/saída do processador) e muitas vezes suas características e seu comportamento dependem da tecnologia usada emsua construção. Por exemplo, a forma de acesso de baixo nível a discos rígidos IDE difere da forma de acesso a discos SCSI ou leitores de CD. Essa grande diversidade pode ser uma fonte de dores de cabeça para o desenvolvedor de aplicativos. Portanto, torna-se desejável oferecer aos programas aplicativos uma forma de acesso homogênea aos dispositivos físicos, que permita abstrair as diferenças tecnológicas entre eles.

O sistema operacional é uma camada de software que opera entre o hardware e os programas aplicativos voltados ao usuário final. O sistema operacional é uma estrutura de software ampla,muitas vezes complexa, que incorpora aspectos de baixo nível (como drivers de dispositivos e gerência de memória física) e de alto nível (como programas utilitários e a própria interface gráfica).

A figura 1 ilustra a arquitetura geral de um sistema de computação típico. Nela, podemos observar elementos de hardware, o sistema operacional e alguns programas aplicativos.




4 Histórico dos sistemas operacionais Os primeiros sistemas de computação, no final dos anos 40 e início dos anos 50, não possuíam sistema operacional. Por outro lado, os sistemas de computação atuais possuem sistemas operacionais grandes, complexos e em constante evolução. A seguir são apresentados alguns dos marcos mais relevantes na história dos sistemas operacionais:

Anos 40: cada programa executava sozinho e tinha total controle do computador.

A carga do programa em memória, a varredura dos periféricos de entrada para busca de dados, a computação propriamente dita e o envio dos resultados para os periférico de saída, byte a byte, tudo devia ser programado detalhadamente pelo desenvolvedor da aplicação.

Anos 50: os sistemas de computação fornecem“bibliotecas de sistema” (systemlibraries) que encapsulam o acesso aos periféricos, para facilitar a programação de aplicações.

Algumas vezes um programa “monitor” (system monitor) auxilia a carga e descarga de aplicações e/ou dados entre a memória e periféricos (geralmente leitoras de cartão perfurado, fitas magnéticas e impressoras de caracteres).

1961 : o grupo do pesquisador Fernando Corbató, do MIT, anuncia o desenvolvimento do CTSS – Compatible Time-Sharing System[CDD62], o primeiro sistema operacional com compartilhamento de tempo.

1965 : a IBMlança o OS/360, um sistema operacional avançado, com compartilhamento de tempo e excelente suporte a discos.

1965 : um projeto conjunto entre MIT, GE e Bell Labs define o sistema operacional Multics, cujas idéias inovadoras irão influenciar novos sistemas durante décadas.

1969 : Ken Thompson e Dennis Ritchie, pesquisadores dos Bell Labs, criam a primeira versão do UNIX.

1981 : a Microsoft lança o MS-DOS, um sistema operacional comprado da empresa Seattle Computer Products em 1980.

1984 : a Apple lança o sistema operacional Macintosh OS 1.0, o primeiro a ter uma interface gráfica totalmente incorporada ao sistema.

1985 : primeira tentativa daMicrosoft no campo dos sistemas operacionais cominterface gráfica, através do MS-Windows 1.0.

1987 : Andrew Tanenbaum, um professor de computação holandês, desenvolve um sistema operacional didático simplificado, mas respeitando a API do UNIX, que foi batizado como Minix.

1987 : IBM e Microsoft apresentam a primeira versão do OS/2, um sistema multitarefa destinado a substituir o MS-DOS e o Windows. Mais tarde, as duas empresas rompem a parceria; a IBM continua no OS/2 e a Microsoft investe no ambiente Windows.

1991 : Linus Torvalds, um estudante de graduação finlandês, inicia o desenvolvimento do Linux, lançando na rede Usenet o kernel 0.01, logo abraçado por centenas de programadores ao redor do mundo.

1993 : a Microsoft lança oWindows NT, o primeiro sistema 32 bits da empresa.

1993 : lançamento dos UNIX de código aberto FreeBSD e NetBSD.




2001 : a Apple lança o MacOS X, um sistema operacional derivado da família UNIX BSD.

2001 : lançamento doWindows XP.

2004 : lançamento do núcleo Linux 2.6.

2006 : lançamento doWindows Vista.

Esse histórico reflete apenas o surgimento de alguns sistemas operacionais relativamente populares; diversos sistemas acadêmicos ou industriais de grande importância pelas contribuições inovadoras, como Mach, Chorus, QNX e Plan 9, não estão representados.




5 Sistemas Operacionais

5.1 O que é um sistema operacional? O sistema operacional é o componente de um sistema computacional que faz o interfaceamento homem – maquina, o sistema operacional nos permite controlar todo o sistema de computação dês do hardware até o software.

Podemos considerar um sistema operacional como um alocador de recursos. Um sistema de computação possui muitos recursos (hardware e software) que podem ser necessários para resolver um problema: tempo de CPU, espaço na memória, espaço de armazenamento de arquivos, dispositivos de entrada e saída entre outros.

O sistema operacional atua como gerente de recursos e os aloca a programas e usuários específicos conforme o necessário para a execução das tarefas.

O sistema operacional e um software que esta sempre em execução no computador.

5.2 Tipos de sistemas operacionais

Os sistemas operacionais podem ser classificados segundo diversos parâmetros e perspectivas, como tamanho, velocidade, suporte a recursos específicos, acesso à rede, etc. A seguir são apresentados alguns tipos de sistemas operacionais usuais (muitos sistemas operacionais se encaixam bem em mais de uma das categorias apresentadas):

5.2.1 Sistema operacional em lote (Batch) os sistemas operacionais mais antigos trabalhavam “por lote”, ou seja, todos os programas a executar eram colocados em uma fila, com seus dados e demais informações para a execução. O processador recebia um programa após o outro, processando-os em seqüência, o que permitia um alto grau de utilização do sistema. Ainda hoje o termo “em lote” é usado para designar um conjunto de comandos que deve ser executado em seqüência, sem interferência do usuário.

Exemplos desses sistemas incluem o OS/360 e VMS, entre outros.

5.2.2 Sistema de tempo compartilhado

O tempo compartilhado, ou multitarefa, é uma extensão lógica da multiprogramação. A CPU executa vários jobs alternando entre eles, mas as trocas ocorrem com tanta freqüência que os usuários podem interagir com cada programa durante sua execução.

Um sistema interativo permite a comunicação direta entre o usuário e o sistema. O usuário passa informações ao sistema operacional ou a um programa diretamente, usando um teclado ou mouse, e espera resultados imediatos.

Um sistema operacional de tempo compartilhado utiliza o escalonamento de CPU e a multiprogramação para oferecer a cada usuário uma pequena parte de um computador de tempo compartilhado.

Um programa carregado na memória e executando é normalmente chamado de processo.

Os sistema de tempo compartilhado são bem mais complexos que os multiprogramados.




A idéia de tempo compartilhado foi apresentada pela primeira vez em 1960, mas como os sistemas de tempo compartilhado são difíceis e caros de construir, só se tornaram comuns no inicio dos anos 70.

5.2.3 Sistemas de computadores pessoais (Desktop) Os computadores pessoais apareceram nos anos 70. Durante a primeira década, a CPU ns PCs não tinha os recursos necessários para proteger um sistema operacional dos programas do usuário. Os sistemas operacionais para PC, protanto, não eram nem multiuruário nem multitarefa.

A meta destes sistemas operacionais mudaram com o tempo; em vez de maximizar a utilização da CPU e periféricos, os sistemas optam por maximizar a conveniência e a capacidade de resposta ao usuário.

um sistema operacional “de mesa” é voltado ao atendimento do usuário doméstico e corporativo para a realização de atividades corriqueiras, como edição de textos e gráficos, navegação na Internet e reprodução de mídias simples. Sua principais características são a interface gráfica, o suporte à interatividade e a operação em rede. Exemplos de sistemas desktop são o Windows XP, MacOS X e Linux.

5.2.4 Sistemas paralelos A maioria dos sistemas existentes até hoje são sistema de um único processador, ou seja, só tem uma CPU principal. No entanto, existe uma tendência em direção aos sistemas de multiprocessador. Tais sistemas têm mais de um processador em comunicação ativa, compartilhando o barramento, o clock, e as vezes, a memória e os dispositivos periféricos.

Uma vantagem e a maior produção. Aumentando o numero de processadores, espera-se realizar mais trabalho em menos tempo.

A taxa de aumento de velocidade com n processadores, entretanto, não é n, mas menor que n.

Se houver dez processadores e um falhar, cada um dos nove processadores restantes deverá pegar uma parte do trabalho do processador que falhou. Assim o sistema inteiro executa apenas 10% mais lentamente, em vez de parar por completo.

Existem dois tipos de multiprocessamento, o multiprocessamento assimétrico e o simétrico.

No assimétrico a cada processador é atribuído uma tarefa específica. Um processador mestre controla o sistema; os outros processadores procuram o mestre para receber instruções ou tem tarefas predefinidas. Esse esquema define uma relação mestre-escravo. O processador mestre escalona e aloca trabalho para os processadores escravos.

No multiprocessamento simétrico, todos os processadores são iguais; não existindo a relação mestre-escravo entre eles. Cada processador executa uma copia do sistema operacional de forma concorrente.

5.2.5 Sistema de tempo real Ao contrário da concepção usual, um sistema operacional de tempo real não precisa ser necessariamente ultra-rápido; sua característica essencial é ter um comportamento temporal previsível (ou seja, seu tempo de resposta deve ser conhecido no melhor e pior caso de operação). A estrutura interna de um sistema operacional de tempo real




deve ser construída de forma a minimizar esperas e latências imprevisíveis, como tempos de acesso a disco e sincronizações excessivas.

Um sistema de tempo real é usado quando existem requisitos rígidos de tempo na operação de um processador ou no fluxo de dados; assim ele geralmente e usado como um dispositivo de controle em uma aplicação dedicada.

Os sensores levam dados ao computador. O computador deve analisar os dados e talvez ajustar os controles para modificar as características dos sensores.

Os sistemas que controlam experimentos científicos, sistemas de imagens médicas, sistemas de controle industrial, alguns sistema de injeção de combustíveis de veículos, sistemas de armas e outros.

Existem duas classificações de sistemas de tempo real: soft real-time systems, nos quais a perda de prazos implica na degradação do serviço prestado.

Um exemplo seria o suporte à gravação de CDs ou à reprodução de músicas. Caso o sistema se atrase, pode ocorrer a perda da mídia em gravação ou falhas na música que está sendo tocada.

Por outro lado, nos hard real-time systems a perda de prazos pelo sistema pode perturbar o objeto controlado, com graves conseqüências humanas, econômicas ou ambientais.

Exemplos desse tipo de sistema seriam o controle de funcionamento de uma turbina de avião a jato ou de uma caldeira industrial.

Exemplos de sistemas de tempo real incluemoQNX, RT-Linux e VxWorks.

Muitos sistemas embutidos têm características de tempo real, e vice-versa.

5.2.6 Sistemas distribuídos Em um sistema operacional distribuído, os recursos de cada máquina estão disponíveis globalmente, de forma transparente aos usuários. Ao lançar uma aplicação, o usuário interage com sua janela, mas não sabe onde ela está executando ou armazenando seus arquivos: o sistema é quem decide, de forma transparente. Os sistemas operacionais distribuídos já existem há tempos (Amoeba e Clouds, por exemplo),mas ainda não são uma realidade de mercado.

5.2.7 Sistemas Multi-usuário Um sistema operacionalmulti-usuário deve suportar a identificação do “dono” de cada recurso dentro do sistema (arquivos, processos, áreas dememória, conexões de rede) e impor regras de controle de acesso para impedir o uso desses recursos por usuários não autorizados. Essa funcionalidade é fundamental para a segurança dos sistemas operacionais de rede e distribuídos. Grande parte dos sistemas atuais são multi-usuários.

5.2.8 Sistemas de servidor Um sistema operacional servidor deve permitir a gestão eficiente de grandes quantidades de recursos (disco, memória, processadores), impondo prioridades e limites sobre o uso dos recursos pelos usuários e seus aplicativos. Normalmente um sistema operacional servidor também tem suporte a rede e multi-usuários.




5.2.9 Sistemas embutidos (embarcados) Um sistema operacional é dito embutido (embedded) quando é construído para operar sobre um hardware com poucos recursos de processamento, armazenamento e energia. Aplicações típicas desse tipo de sistema aparecem em telefones celulares, controladores industriais e automotivos, equipamentos eletrônicos de uso doméstico (leitores de DVD, TVs, fornos-micro-ondas, centrais de alarme, etc.). Muitas vezes um sistema operacional embutido se apresenta na forma de uma biblioteca a ser ligada ao programa da aplicação (que é fixa). Exemplos de sistemas operacionais embutidos são o µC/OS, Xylinx, LynxOS e VxWorks.

5.3 Funcionalidades do sistema operacional Para cumprir seus objetivos de abstração e gerência, o sistema operacional deve atuar em várias frentes. Cada um dos recursos do sistema possui suas particularidades, o que impõe exigências específicas para gerenciar e abstrair os mesmos. Sob esta perspectiva, as principais funcionalidades implementadas por um sistema operacional típico são:

5.3.1 Gerência do processador Também conhecida como gerência de processos ou de atividades, esta funcionalidade visa distribuir a capacidade de processamento de forma justa1 entre as aplicações, evitando que uma aplicação monopolize esse recurso e respeitando as prioridades dos usuários. O sistema operacional provê a ilusão de que existe um processador independente para cada tarefa, o que facilita o trabalho dos programadores de aplicações e permite a construção de sistemas mais interativos. Também faz parte da gerência de atividades fornecer abstrações para sincronizar atividades inter-dependentes e prover formas de comunicação entre elas.

5.3.2 Gerência de memória Tem como objetivo fornecer a cada aplicação uma área de memória própria, independente e isolada das demais aplicações e inclusive do núcleo do sistema. O isolamento das áreas de memória das aplicações melhora a estabilidade e segurança do sistema como um todo, pois impede aplicações com erros (ou aplicações maliciosas) de interferir no funcionamento das demais aplicações.

Além disso, caso a memória RAM existente seja insuficiente para as aplicações, o sistema operacional pode aumentá-la de forma transparente às aplicações, usando o espaço disponível em um meio de armazenamento secundário (como um disco rígido). Uma importante abstração construída pela gerência de memória é a noção de memória virtual, que desvincula os endereços de memória vistos por cada aplicação dos endereços acessados pelo processador na memória RAM. Com isso, uma aplicação pode ser carregada em qualquer posição livre da memória, sem que seu programador tenha de se preocupar com os endereços de memória onde ela irá executar.

5.3.3 Gerência de dispositivos Cada periférico do computador possui suas peculiaridades; assim, o procedimento de interação com uma placa de rede é completamente diferente da interação comum disco rígido SCSI. Todavia, existem muitos problemas e abordagens em comum para o acesso aos periféricos. Por exemplo, é possível criar uma abstração única para a maioria dos dispositivos de armazenamento como pen-drives, discos SCSI ou IDE, disquetes, etc, na forma de um vetor de blocos de dados. A função da gerência de dispositivos (também conhecida como gerência de entrada/saída) é implementar a




interação com cada dispositivo por meio de drivers e criar modelos abstratos que permitam agrupar vários dispositivos distintos sob a mesma interface de acesso.

5.3.4 Gerência de arquivos Esta funcionalidade é construída sobre a gerência de dispositivos e visa criar arquivos e diretórios, definindo sua interface de acesso e as regras para seu uso. É importante observar que os conceitos abstratos de arquivo e diretório são tão importantes e difundidos que muitos sistemas operacionais os usam para permitir o acesso a recursos que nada tem a ver com armazenamento.

Exemplos disso são as conexões de rede (nos sistemas UNIX e Windows, cada socket TCP é visto como um descritor de arquivo no qual pode-se ler ou escrever dados) e as informações do núcleo do sistema (como o diretório /proc do UNIX).

No sistema operacional experimental Plan 9, todos os recursos do sistema operacional são vistos como arquivos.

5.3.5 Gerência de proteção Com computadores conectados em rede e compartilhados por vários usuários, é importante definir claramente os recursos que cada usuário pode acessar, as formas de acesso permitidas (leitura, escrita, etc) e garantir que essas definições sejam cumpridas. Para proteger os recursos do sistema contra acessos indevidos, é necessário:

a) definir usuários e grupos de usuários;

b) identificar os usuários que se conectam ao sistema, através de procedimentos de autenticação;

c) definir e aplicar regras de controle de acesso aos recursos, relacionando todos os usuários, recursos e formas de acesso e aplicando essas regras através de procedimentos de autorização; e finalmente

d) registrar o uso dos recursos pelos usuários, para fins de auditoria e contabilização.

Além dessas funcionalidades básicas oferecidas pela maioria dos sistemas operacionais, várias outras vêm se agregar aos sistemas modernos, para cobrir aspectos complementares, como a interface gráfica, suporte de rede, fluxos multimídia, gerência de energia, etc.

As funcionalidades do sistema operacional geralmente são inter-dependentes: por exemplo, a gerência do processador depende de aspectos da gerência dememória, assim como a gerência de memória depende da gerência de dispositivos e da gerência de proteção.

Alguns autores representam a estrutura do sistema operacional conforme indicado na figura 2. Nela, o núcleo central implementa o acesso de baixo nível ao hardware, enquanto os módulos externos representam as várias funcionalidades do sistema.




Uma regra importante a ser observada na construção de um sistema operacional é a separação entre os conceitos de política e mecanismo. Como política consideram-se os aspectos de decisão mais abstratos, que podem ser resolvidos por algoritmos de nível mais alto, como por exemplo decidir a quantidade de memória que cada aplicação ativa deve receber, ou qual o próximo pacote de rede a enviar para satisfazer determinadas especificações de qualidade de serviço.

Por outro lado, como mecanismo consideram-se os procedimentos de baixo nível usados para implementar as políticas, ou seja, atribuir ou retirarmemória de uma aplicação, enviar ou receber um pacote de rede, etc. Os mecanismos devem ser suficientemente genéricos para suportar mudanças de política sem necessidade de modificações. Essa separação entre os conceitos de política e mecanismo traz uma grande flexibilidade aos sistemas operacionais, permitindo alterar sua personalidade (sistemas mais interativos ou mais eficientes) sem ter de alterar o código que interage diretamente com o hardware.

Alguns sistemas, como o InfoKernel, permitem que as aplicações escolham as políticas do sistema mais adequadas às suas necessidades.

5.4 Estrutura de um sistema operacional Um sistema operacional não é um bloco único e fechado de software executando sobre o hardware. Na verdade, ele é composto de diversos componentes com objetivos e funcionalidades complementares. Alguns dos componentes mais relevantes de um sistema operacional típico são:

5.4.1 Núcleo É o coração do sistema operacional, responsável pela gerência dos recursos do hardware usados pelas aplicações. Ele também implementa as principais abstrações utilizadas pelos programas aplicativos.




5.4.2 Drivers Módulos de código específicos para acessar os dispositivos físicos. Existe um driver para cada tipo de dispositivo, como discos rígidos IDE, SCSI, portas USB, placas de vídeo, etc. Muitas vezes o driver é construído pelo próprio fabricante do hardware e fornecido em forma compilada (em linguagem de máquina) para ser acoplado ao restante do sistema operacional.

5.4.3 Código de inicialização A inicialização do hardware requer uma série de tarefas complexas, como reconhecer os dispositivos instalados, testá-los e configurá-los adequadamente para seu uso posterior. Outra tarefa importante é carregar o núcleo do sistema operacional em memória e iniciar sua execução.

5.4.4 Programas utilitários São programas que facilitam o uso do sistema computacional, fornecendo funcionalidades complementares ao núcleo, como formatação de discos e mídias, configuração de dispositivos, manipulação de arquivos (mover, copiar, apagar), interpretador de comandos, terminal, interface gráfica, gerência de janelas, etc. As diversas partes do sistema operacional se relacionam entre si conforme apresentado na figura 3.




5.5 Gerência de tarefas Em um sistema de computação, é freqüente a necessidade de executar várias tarefas distintas simultaneamente. Por exemplo:

• O usuário de um computador pessoal pode estar editando uma imagem, imprimindo um relatório, ouvindo música e trazendo da Internet um novo software, tudo ao mesmo tempo.

• Em um grande servidor de e-mails, centenas de usuários conectados remotamente enviam e recebem e-mails através da rede.

• Um navegador Web precisa buscar os elementos da página a exibir, analisar e renderizar o códigoHTML e o gráficos recebidos, animar os elementos da interface e responder aos comandos do usuário.

No entanto, um processador convencional somente trata um fluxo de instruções decada vez. Até mesmo computadores com vários processadores (máquinas Dual Pentium ou processadores com tecnologia hyper-threading, por exemplo) têm mais atividades a executar que o número de processadores disponíveis. Como fazer para atender simultaneamente as múltiplas necessidades de processamento dos usuários? Uma solução ingênua seria equipar o sistema com um processador para cada tarefa, mas essa solução ainda é inviável econômica e tecnicamente. Outra solução seria multiplexar o processador entre as várias tarefas que requerem processamento. Por multiplexar entendemos compartilhar o uso do processador entre as várias tarefas, de forma a atendê-las da melhor maneira possível.

Os principais conceitos abordados nesta parte do capítulo compreendem: • Como as tarefas são definidas; • Quais os estados possíveis de uma tarefa; • Como e quando o processador muda de uma tarefa para outra; • Como ordenar (escalonar) as tarefas para usar o processador.

5.6 O conceito de tarefa Uma tarefa é definida como sendo a execução de um fluxo seqüencial de instruções, construído para atender uma finalidade específica: realizar um cálculo complexo, a edição deumgráfico, a formatação deumdisco, etc. Assim, a execução deuma seqüência de instruções em linguagem de máquina, normalmente gerada pela compilação de um programa escrito em uma linguagem qualquer, é denominada “tarefa” ou “atividade” (do inglês task). É importante ressaltar as diferenças entre os conceitos de tarefa e de programa:

Um programa é um conjunto de uma ou mais seqüências de instruções escritas para resolver um problema específico, constituindo assim uma aplicação ou utilitário. O programa representa um conceito estático, sem um estado interno definido (que represente uma situação específica da execução) e sem interações com outras entidades (o usuário ou outros programas). Por exemplo, os arquivos C:\Windows\notepad.exe e /usr/bin/nano são programas de edição de texto.

Uma tarefa é a execução, pelo processador, das seqüências de instruções definidas em um programa para realizar seu objetivo. Trata-se de um conceito dinâmico, que possui um estado interno bem definido a cada instante (os valores das variáveis internas e a posição atual da execução) e interage comoutras entidades: o usuário, os periféricos e/ou outras tarefas. Fazendo uma analogia clássica, pode-se dizer que um programa é o equivalente de uma “receita de torta” dentro de um livro de receitas (um diretório) guardado em uma




estante (umdisco) na cozinha (o computador). Essa receita de torta define os ingredientes necessários e o modo de preparo da torta. Por sua vez, a ação de “executar” a receita, providenciando os ingredientes e seguindo os passos definidos na receita, é a tarefa propriamente dita. A cada momento, a cozinheira (o processador) está seguindo um passo da receita (posição da execução) e tem uma certa disposição dos ingredientes e utensílios em uso (as variáveis internas da tarefa). Assim como uma receita de torta pode definir várias atividades inter-dependentes para elaborar a torta (preparar a massa, fazer o recheio, decorar, etc), um programa tambémpode definir várias seqüências de execução inter-dependentes para atingir seus objetivos. Por exemplo, o programa do navegador Web ilustrado na figura abaixo define várias tarefas que uma janela de navegador deve executar simultaneamente, para que o usuário possa navegar na Internet:

Figura: Tarefas de um navegador Internet 1. Buscar via rede os vários elementos que compõem a página Web;

2. Receber, analisar e renderizar o código HTML e os gráficos recebidos;

3. Animar os diferentes elementos que compõem a interface do navegador;

4. Receber e tratar os eventos do usuário (clicks) nos botões do navegador;

Dessa forma, o processador tem então de se multiplexar entre todas as tarefas definidas nessa “receita de torta” (e outras tarefas que possam estar sendo executadas pelos usuários) para atingir os objetivos esperados. Às vezes podemos ter mais de uma cozinheira trabalhando juntas na mesma cozinha, o que irá agilizar o trabalho, mas também tornará mais complexa a gerência das tarefas.

4

1

2

3




5.7 A gerência de tarefas Os primeiros sistemas de computação, nos anos 40, executavam apenas uma tarefa de cada vez. Nestes sistemas, cada programa binário era carregado do disco para a memória e executado até sua conclusão. Os dados de entrada da tarefa eramcarregados na memória juntamente com a mesma e os resultados obtidos no processamento eram descarregados de volta no disco após a conclusão da tarefa. Todas as operações de transferência de código e dados entre o disco e a memória eram coordenados por um operador humano. Esses sistemas primitivos eramusados sobretudo para aplicações de cálculo numérico,muitas vezes comfinsmilitares (problemas de trigonometria, balística, mecânica dos fluidos, etc). A figura a seguir ilustra um sistema desse tipo.

Figura: Sistema mono-tarefa: 1) carga do código na memória, 2) carga dos dados na memória, 3) processamento, consumindo dados e produzindo resultados, 4) ao término da execução, a descarga dos resultados no disco. Nesse método de processamento de tarefas é possível delinear um diagrama de estados para cada tarefa executada pelo sistema, que está representado na figura abaixo.

Coma evolução do hardware, as tarefas de carga e descarga de código entre memória e disco, coordenadas por um operador humano, passaram a se tornar críticas: mais

Figura: Diagrama de estados de uma tarefa em um sistema mono-tarefa.

tempo era perdido nesses procedimentos manuais que no processamento da tarefa em si. Para resolver esse problema foi construído um programa monitor, que era carregado namemória no início da operação do sistema coma função de coordenar a execução dos demais programas. O programa monitor executava basicamente os seguintes passos sobre uma fila de programas a executar, armazenada no disco:

repetir carregar um programa do disco para a memória




carregar os dados de entrada do disco para a memória transferir a execução para o programa recém carregado aguardar o término da execução do programa escrever os resultados gerados pelo programa no disco

até processar todos os programas da fila

Percebe-se claramente que a função do monitor é gerenciar uma fila de programas a executar, mantida no disco. Na medida em que os programas são executados pelo processador, novos programas podem ser inseridos na fila pelo operador do sistema. Além de coordenar a execução dos demais programas, o monitor também colocava à disposição destes uma biblioteca de funções para simplificar o acesso aos dispositivos de hardware (teclado, leitora de cartões, disco, etc). Assim, o monitor de sistema constitui o precursor dos sistemas operacionais.

O uso do programa monitor agilizou o uso do processador, mas outros problemas persistiam. Como a velocidade de processamento era muito maior que a velocidade de comunicação com os dispositivos de entrada e saída1, o processador ficava ocioso durante os períodos de transferência de informação entre disco ememória. Se a operação de entrada/saída envolvia fitas magnéticas, o processador podia ficar vários minutos parado, esperando. O custo dos computadores era elevado demais (e sua capacidade de processamento muito baixa) para permitir deixá-los ociosos por tanto tempo.

A solução encontrada para resolver esse problema foi permitir ao processador suspender a execução da tarefa que espera dados externos e passar a executar outra tarefa.

Mais tarde, quando os dados de que necessita estiverem disponíveis, a tarefa suspensa pode ser retomada no ponto onde parou. Para tal, é necessário ter mais memória (para poder carregar mais de um programa ao mesmo tempo) e definir procedimentos para suspender uma tarefa e retomá-la mais tarde. O ato de retirar um recurso de uma tarefa (neste caso o recurso é o processador) é denominado preempção. Sistemas que implementam esse conceito são chamados sistemas preemptivos.

A adoção da preempção levou a sistemas mais produtivos (e complexos), nos quais várias tarefas podiam estar em andamento simultaneamente: uma estava ativa e as demais suspensas, esperando dados externos ou outras condições. Sistemas que suportavam essa funcionalidade foram denominados monitores multi-tarefas. O diagrama de estados da figura abaixo ilustra o comportamento de uma tarefa em um sistema desse tipo:

Figura: Diagrama de estados de uma tarefa em um sistema multi-tarefas.

1Essa diferença de velocidades permanece imensa nos sistemas atuais. Por exemplo, em um computador atual a velocidade de acesso à memória é de cerca de 10 nanossegundos (10 × 10−9s), enquanto a velocidade de acesso a dados em um disco rígido IDE é de cerca de 10 milissegundos (10 × 10−3s), ou seja, um milhão de vezes mais lento!




Solucionado o problema de evitar a ociosidade do processador, restavam no entanto vários outros problemas a resolver. Por exemplo, um programa que contém um laço infinito jamais encerra; como fazer para abortar a tarefa, ou ao menos transferir o controle ao monitor para que ele decida o que fazer? Situações como essa podem ocorrer a qualquer momento, por erros de programação ou intencionalmente, como mostra o exemplo a seguir:

Esse tipo de programa pode inviabilizar o sistema, pois a tarefa em execução nunca termina nem solicita operações de entrada/saída, monopolizando o processador e impedindo a execução das demais tarefas (pois o controle nunca volta ao monitor). Além disso, essa solução não era adequada para a criação de aplicações interativas. Por exemplo, um terminal de comandos pode ser suspenso a cada leitura de teclado, perdendo o processador. Se ele tiver de esperar muito para voltar ao processador, a interatividade com o usuário fica prejudicada.

Para resolver essa questão, foi introduzido no início dos anos 60 um novo conceito: o compartilhamento de tempo, ou time-sharing, através do sistema CTSS – Compatible Time-Sharing System. Nessa solução, cada atividade que detém o processador recebe um limite de tempo de processamento, denominado quantum2. Esgotado seu quantum, a tarefa em execução perde o processador e volta para uma fila de tarefas “prontas”, que estão na memória aguardando sua oportunidade de executar. Essa “preempção por tempo de processamento” é implementada coma ajuda de temporizadores externos programáveis (implementados em hardware) que geram interrupções ao disparar.

O diagrama de estados das tarefas deve ser reformulado para incluir a preempção por tempo que implementa a estratégia de tempo compartilhado. A figura abaixo apresenta esse novo diagrama, que é conhecido na literatura da área como diagrama de ciclo de vida das tarefas.

Figura: Diagrama de estados de uma tarefa em um sistema de tempo compartilhado. 2A duração atual do quantum depende muito do tipo de sistema operacional; no Linux ela varia de 10 a 200 milissegundos, dependendo do tipo e prioridade da tarefa.




Os estados e transições do ciclo de vida apresentado na figura acima têm o seguinte significado: Nova : A tarefa está sendo criada, i.e. seu código está sendo carregado em memória, junto comas bibliotecas necessárias, e as estruturas de dados do núcleo estão sendo atualizadas para permitir sua execução. Pronta : A tarefa está em memória, pronta para executar (ou para continuar sua execução), apenas aguardando a disponibilidade do processador. Todas as tarefas prontas são organizadas em uma fila cuja ordem é determinada por algoritmos de escalonamento. Executando : O processador está dedicado à tarefa, executando suas instruções e fazendo avançar seu estado. Suspensa : A tarefa não pode executar porque depende de dados externos ainda não disponíveis (do disco ou da rede, por exemplo), aguarda algum tipo de sincronização (o fim de outra tarefa ou a liberação de algum recurso compartilhado) ou simplesmente espera o tempo passar (em uma operação sleeping, por exemplo). Terminada : O processamento da tarefa foi encerrado e ela pode ser removida da memória do sistema. Tão importantes quanto os estados das tarefas apresentados na figura 5 são as transições entre esses estados, que são explicadas a seguir: · · · !Nova : Esta transição ocorre quando uma nova tarefa é admitida no sistema e começa a ser preparada para executar. Nova!Pronta : ocorre quando a nova tarefa termina de ser carregada em memória, juntamente com suas bibliotecas e dados, estando pronta para executar. Pronta!Executando : esta transição ocorre quando a tarefa é escolhida pelo escalonador para ser executada, dentre as demais tarefas prontas. Executando!Pronta : esta transição ocorre quando se esgota a fatia de tempo destinada à tarefa (ou seja, o fimdo quantum); como nessemomento a tarefa não precisa de outros recursos além do processador, ela volta à fila de tarefas prontas, para esperar novamente o processador. Executando!Terminada : ocorre quando a tarefa encerra sua execução ou é abortada em conseqüência de algum erro (acesso inválido à memória, instrução ilegal, divisão por zero, etc). Na maioria dos sistemas a tarefa que deseja encerrar avisa o sistema operacional através de uma chamada de sistema (no Linux é usada a chamada exit). Terminada! · · · : Uma tarefa terminada é removida da memória e seus registros e estruturas de controle no núcleo são apagadas. Executando!Suspensa : caso a tarefa em execução solicite acesso a um recurso não disponível, como dados externos ou alguma sincronização, ela abandona o processador e fica suspensa até o recurso ficar disponível. Suspensa!Pronta : quando o recurso solicitado pela tarefa se torna disponível, ela pode voltar a executar, portanto volta ao estado de pronta.




6 Sistema Operacional MS-DOS Ao contrário do UNIX, que roda numa grande variedade de máquinas diferentes, o MS-DOS só roda em arquiteturas baseadas nos processadores Intel 8088 e seus sucessores. Quando foi lançado era considerado um sistema de fácil utilização e que trabalhava bem com os equipamentos existentes na época. O que veremos neste capitulo, é um pouco da história deste sistema operacional, como ele funcionava e em uma parte bem prática seu funcionamento e comandos de sistema.

6.1 HISTÓRIA DO MS-DOS O primeiro computador pessoal foi o Altair, produzido em 1975 por uma companhia chamada MITS, de Albuquerque, Novo México, EUA. Ele era baseado no microprocessador 8080, de oito bits, fabricado pela Intel, e tinha 256 bytes de memória. O Altair, não tinha teclado, nem vídeo, muito menos dicos ou fitas, mas seu preço muito baixo, em torno de 400 dólares, tranformou-o num cult para eletrônicos amadores, que cresceram montando kits de rádio e televisões vendidos em bancas de jornal. Um jovem chamado Bill Gates escreveu uma versão BASIC para o Altair, que obteve um sucesso modesto junto ao usuários do microcomputador. Mais tarde este programa veio a fazer de Gates um bilionário. Em poucos anos muitas empresas começaram a produzir micro computadores baseados no chip 8080. Em quase todas essas máquinas, rodava um sistema operacional chamado CP/M, produzido por uma pequena empresa da Califórnia, a Digital Research. Todos os computadores pessoais (chamados microcomputadores) projetados de 1975 até o início da década de 80 nada mais eram do que brinquedos comprados e utilizados fundamentalmente pelas pessoas que tinham a eletrônica como hobby.

6.1.1 O IBM PC No início dos anos 80, a IBM, que então dominava a indústria de computadores, deciciu entrar no negócio da computação pessoal. No entanto, como ela custou a tomar uma decisão sobre o assunto, já era tarde para desenvolver um projeto próprio. Por conta disso, seus executivos decidiram fazer algo que não era usual para a normalmente cautelosa e burocrática IBM. Enviaram um de seus gerentes, Philip Estridge, para Boca Raton, na Flórida, a dois mil quilômetros do quartel-general da corporação, situado no condado de Westchester, Nova Iorque, com uma mala cheia de dinheiro, com a recomendação de não voltar de Nova Iorque sem um projeto de computador pessoal no bolso. Estridge percebeu logo que a única maneira de se produzir rapidamente um computador pessoal era utilizando componentes-padrão, em vez dos projetados internamente, pela própeia IBM, como ela sempre fazia. Nesta época, a Intel já tinha produzido dois sucessores para o 8080, o 8086, de 16 bits, e o 8088, uma versão do 8086, com barramento de 8 bits. Estridges escolheu, pois os chips que davam suporte a esse processador eram muito mais baratos que o dos 8086. Esta decisão baseou-se no fato de o preço de venda da máquina ser o ponto de maior importância no projeto. Além de não ter interesse em construir ela própria os chips para equipar seu computador pessoal, a IBM estava muito menos interessada em escrever um software para ele. Seus executivos sabiam que o BASIC era muito popular entre os usuários de




computadores pessoais, de modo que eles foram consultar Bill Gates, que nesta época já tinha fundado uma nova empresa, chamada Microsoft, afim de licensiar o interpretador BASIC para ser usado no IBM-PC. Pediram também que Gates desenvolvesse um sistema operacional para a nova máquina. A Microsoft, porém, estava dedicada ao projeto de vender o UNIX, sob licemsa de Bell Labs (AT & T). Ocorre que o UNIX originário do mundo dos mini computadores, precisava de 100Kb de memória só para o sistema operacional e também de um disco rígido. A máquina da IBM, tinha um total de 64k de memória e não era equipada com disco rígido. Em função disso, Gates sugeriu que a IBM usasse o CP/M – 86, desenvolveido pela Digital Research. A IBM consultou a Digital Research, que respondeu que o desenvolvimento dos CP/M – 86 estava atrasado em relação ao cronograma original, e a IBM não podia esperar. A Microsoft foi então mais uma vez procurada, desta vez consultada sobre a possibilidade de escrever um sistema operacional com as mesmas características do CP/M – 86. Os projetos de Gates o impediram de assumir a empreitada e realizá-la no prazo exigido pela IBM. Ele, porém, sabia que uma empresa vizinha da Microsoft, a Seattle Computer Products, havia desenvolvido um sistema operacional CP/M – like, denominado 86 – DOS , para testar as placas de memória que ela produzia e vendia. A Microsoft então comprou o 86 – DOS, e em abril de 1981, contratou seu projetista, Tim Paterson, para torná-lo ainda menor. Eles mudaram o nome do sistema para MS-DOS (Micro Soft – Disk Operating System), entregando-o a IBM dentro do prazo contratado. Quando o IBM PC foi anunciado com pompa de circunstância em agosto de 1981, o MS-DOS estava lá junto com ele. Na versão da IBM e de muitos outros fabricantes, a maior virtude do MS-DOS era a de permitir que softwares desenvolvidos para CP/M, que rodavam no processador 8080 (o 8088 era compatível com o 8080 e podia rodar a maioria dos seus programas com pouquíssimas modificações), rodassem também sob o MS-DOS. Ninguém poderia imaginar que 10 anos depois este pequeno sistema, que surgiu no mercado quase que por acidente, pudesse estar controlando o funcionamento de 50 milhões de computadores espalhados pelo mundo inteiro. Além do mais, ninguém, nem mesmo a IBM, tinha a menor idéia do sucesso que o IBM PC iria alcançar. A IBM imaginava inicialmente que ele seria usado para jogos. Basta ver que a freqüência de 4,77MHz do seu clock, foi escolhida em função da compatibilidade com a usada nos sistemas de televisão americanas, de maneira a permitir que as pessoas usassem seus próprios aparelhos de TV com vídeo em vez de monitores específicos. O PC também vinha equipado com hardware para controlar aparelhos de gravação/reprodução de fitas cassete, que poderiam ser usadas como meio de armazenamento, e joysticks. Nenhum destes dois dispositivos, teve muito uso, em virtude da inexistência de softwares para eles. Provavelmente a melhor coisa que a IBM fez, foi tornar o PC um sistema aberto. O projeto completo, inclusive as listagem da ROM e os diagramas elétricos foram descrito em detalhes em um livro que estava disponível em todos os pontos de venda dos PCs. Isto fez com que fosse possível usar no PC tanto produtos de Hardware quanto de Software produzidos por terceiros, a exemplo do que foi feito por milhares de fabricantes no mundo inteiro. De fato, com os diagramas de circuitos disponíveis, e a máquina sendo composta exclusivamente por componentes não dedicados, que podiam ser comprados em qualquer loja de eletrônica, muitas empresas passaram a construir e a vender cópias do PC, conhecida como clones, entrando em competição direta com a própria IBM. Foi




devido a esta enorma carga de enrgia e criatividade que o PC teve tanto sucesso, e, a reboque dele, o MS-DOS. É interessante dizer alguma coisa sobre o hardware do PC. Apesar do 8088 dispor de um espaço de endereçamento de 1Mb, a IBM resolveu alocar os primeiros 640k deste espaço para RAM, e o resto para as roms, placas de vídeo e outras coisas. Como consequência, o MS-DOS, foi projetado para suportar programas com tamanho máximo de 640k. Em um primeiro momento, isto não era problema, uma vez que as máquinas só tinham 64 kb de RAM, mas a incapacidade do MS-DOS em rodar programas com mais de 640k , tornou-se um problema sério. E este problema está ajudando na sua quase extinção. Outra característica importante do IBM PC é o fato de ele não dispor de qualquer tipo de proteção por hardware. Os programas são livres para passar por cima do sistema operacional e acessar diretamente o hardware, usualmente com o intuito de obter uma performance melhor. Este estilo de programação resultou em um grande número de programas mal escritos e sem características que permitissem sua portabilidade. Tais programas constituiram-se numa assombração constante para seus criadores, que não raro os recebem de volta. Com a certa complexidade do DOS em termos de comandos, foi criado um ambiente gráfico para ele, o Windows. No Windows, além de ser mais fácil "navegar" entre os programas devido ao sua interface simples de ser interpretada (pastas a diretórios, figuras para o arquivos, cliques do mouse), já era possível rodar dois programas ao mesmo tempo, coisa que o DOS não permitia, porém o acesso a memória ainda era no mesmo esquema do DOS, fazendo que falhas gerais que derrubasse o sistema fossem ainda muito frequentes. Com a necessidade de se criar um sistema operacional que pudesse gerenciar essa memória utilizada pelos programas, impedindo esse acesso direto a memória, utilizando umas interface mais agradável tanto para leigos como para "experts", e a própria economia de tempo graças através de um sistema preemptivo, foi criado o Windows 95 (Sistema Padrão Atual na maioria das máquinas). Porém o Windows 95 não era perfeito, e tinha muitos erros, como qualquer sistema operacional novo, e algumas características do DOS não foram retiradas com intenção de manter a compatibilidade com os programas antigos. Após o windows95 outros sistemas foram desenvolvidos pela MicrosSoft como o windows NT, 98, ME, XP, 2000, 2003, Vista, 2008.

6.2 Eecutando os comandos do MS-DOS Antes de começarmos a ver os comandos, é necessário saber como executá-los. No prompt, você verá o cursor piscando. Isso significa que você já pode digitar. Depois de ter escolhido o comando, tecle Enter. Aqui, para exemplificar usaremos o modelo de prompt "C:\Windows>", mas vale lembrar que "C" pode ser qualquer unidade de disco no seu computador. Normalmente a letra A indica a unidade de disquete. E "Windows" pode significar qualquer pasta dentro da unidade que você está trabalhando. Mas, é importante saber que o DOS geralmente não visualiza nomes de arquivos com mais de 8 caracteres. Por isso, a pasta Meus Documentos, por exemplo, fica assim: MEUSDO~1.




6.2.1 Comandos internos do MS-DOS Os comandos internos podem ser executados em qualquer pasta no PC e a qualquer momento pois estão embutidos no DOS.

Nos comandos internos pode-se saber mais informações acerca do mesmo, digitando /? após o comando, ex.: dir/?, você irá receber informações sobre o comando dir, os comandos internos são os mais úteis em emergências já que podem ser executados em qualquer lugar

6.2.1.1 Comando DATE Esse comando, como o nome já diz, mostra na tela a data atual, permitindo a sua modificação. O comando DATE deverá ser usado da seguinte maneira: date [opções] (Sem os colchetes), sendo que não é necessária a utilização das opções caso você não queira.

Ex.: Digitando date, irá aparecer:

Data atua é: seg 06/10/1997 Digite a nova data: (dd-mm-aa)

Opções:

/t - Informa a data mas não solicita uma nova.

6.2.1.2 Comando TIME Esse comando faz a mesma coisa que o comando DATE mas ao invés de mudar a data ele muda a hora: esse comando mostra hora, minutos, segundos e centésimos de segundo. O comando TIME deverá ser usado da seguinte maneira: Time [opções] (Sem os colchetes), sendo que não é necessária a utilização das opções caso você não queira.

Ex.: Digitando time, irá aparecer:

Hora Atual: 14:20:23,37 Digite a nova Hora:

Opções:

/t - Informa a hora mas não solicita uma nova.

6.2.1.3 Comando VER Esse comando mostra qual sistema operacional você está usando.

Ex.: Digitando ver, irá aparecer:




Microsoft Windows XP [versão 5.1.2600]

6.2.1.4 Comando CLS Esse comando limpa a tela e posiciona o cursor no canto superior esquerdo da tela.

A Figura abaixo mostra varias informações e o comando CLS pronto para ser executado no prompt de comando c:\CLS

A Figura abaixo mostra o comando CLS executado.

6.2.1.5 Comando MEM Comando que fornece informações sobre a memória do computador

Exemplo: Digitando C:\>MEM ira aparecer:




6.2.1.6 Comando Dir O comando dir é muito famoso e quase todos já conhecem: ele mostra todos arquivos e pastas de um diretório, busca arquivos em um drive especificado.

O comando DIR é usado da seguinte maneira: dir [drive:\][caminho\] arquivo(s) [opções] (Sem os colchetes) sendo que não é obrigatório a utilização das opções caso você não queira.

Opções:

/p - A listagem pára toda vez que atinge o fim da tela, sendo necessário que se pressione qualquer tecla para continuar.

/b - Mostra somente as informações básicas.

/c - Mostra o separador de milhar no tamanho dos arquivos.

/w - Exibe a lista na horizontal, onde são mostrados 5 arquivos por linha.

/d - O mesmo que /w, só que mostra a lista em colunas.

/s - Exibe os arquivos de todos os subdiretórios.

/l - Usa letras minúsculas.

/n - Formato de lista longa em que os nomes dos arquivos ficam na extrema direita.

/q - Mostra o nome do dono do arquivo.

/4 - Exibe anos de 4 dígitos.

/t[campo] - Controla qual campo de tempo é exibido ou usado na classificação onde [campo] deve ser substituído por um desses caracteres abaixo..

C - Criação.

A - Último acesso.

W - Última gravação.

/o[ordem] - Mostra os arquivos em uma ordem, onde [ordem] deve ser substituída por um desses caracteres listados abaixo.

N - Nome do arquivo seguido pela extensão.

S - Tamanho do arquivo.

D - Ordem cronológica.




G - Grupos de arquivos de subdiretórios.

/a[atributo] - Mostra somente arquivos de determinado atributo, onde [atributo] deve ser substituído por algum desses caracteres listados abaixo.

D - Nome do arquivo seguido pela extensão.

R - Arquivos somente leitura.

H - Arquivos ocultos .

Obs.: Para reverter o efeito dos caracteres, é necessário a colocação de um hífen (-)

Ex.: Dir /a-h, mostra todos os arquivos menos os arquivos ocultos. A figura abaixo mostra um exemplo de utilização do comando DIR.

6.2.1.7 Comando para mudar a unidade de trabalho No computador existem varias unidades lógicas onde C:\> é a unidade lógica principal, isso significa que quando trabalhamos e visualizamos no prompt de comando a unidade C:\> estamos trabalhando no disco rígido da maquina, mas existem certas ocasiões como no caso de acessar um CD, DVD, uma Pendrive e outros dispositivos que será necessária talvez uma mudança de unidade.

O comando para mudar uma unidade nada mais é do que a letra da própria unidade que você deseja acessar, como no exemplo abaixo onde o usuário pretende acessar um disquete no driver.

C:\> A:




6.2.1.8 Comandos de diretório

6.2.1.8.1 Comando MKDIR ou MD

Comando que cria um diretório a partir do diretório corrente com o nome especificado.

Sintaxe: MD [caminho] { Nome } ou MKDIR [caminho] { Nome }

Exemplo:

C:\>MD PROFESSOR

C:\>MKDIR PROFESSOR

6.2.1.8.2 Comando CHDIR ou CD

Comando utilizado para navegação entre diretórios (pastas), ou seja entrar e sair de diretórios.

Sintaxe: CD [caminho] ou CHDIR [caminho]

Exemplo:

C:\>CD \PROFESSOR , alterna para o diretório PROFESSOR

C:\>CD \PROFESSOR\ALUNOS , alterna para o subdiretório ALUNOS do diretório

Obs. A barra é um item opcional, podendo ser substituída por um espaço em branco, exceto quando o usuário tiver a necessidade entrar diretamente em um subdiretório como mostrado na figura acima oude mudar de um subdiretório para o diretório raiz C:\> como você pode visualizar na figura abaixo.

As opções 2 pontos .. pode e é utilizada para mudar de subdiretórios para diretório raiz ou unidade raiz, como se pode ver na figura abaixo.

6.2.1.8.3 Comando RD ou RMDIR

Remove uma pasta que esteja vazia, sendo que não consegue remover pastas com arquivos. Deve ser usado da seguinte maneira: rd [opções] (Sem colchetes), sendo que não é necessária a utilização das opções caso você não queira.




Ex.: Digitando RD Teste você irá excluir a pasta teste.

Opções:

/s - Remove todas as pastas e arquivos da pasta, além dela mesma.

/q - Modo silencioso, não pede confirmação para remover a árvore de pastas quando usado com /s.

6.2.1.9 Comando TYPE Mostra o conteúdo de um arquivo (somente um por vez e não aceita caracteres curinga).

Sintaxe: TYPE [unidade:] [CAMINHO] { Nome do Arquivo }

Exemplo:

C:\TYPE SERIAL.TXT Exibe o conteúdo do arquivo SERIAL.TXT na tela

Utilizando este comando você pode também imprimir o conteúdo de um arquivo bastando para tanto adicionar a terminação > PRN ou > LPT1 ao comando

Exemplo:

C:\>TYPE CONFIG.SYS > PRN Imprime o conteúdo do arquivo CONFIG.SYS

6.2.1.10 Comando MORE Comando que exibe o conteúdo de um determinado arquivo, fazendo uma pausa cada vez que a tela é preenchida.

Sintaxe: MORE < [unidade:] [caminho] { Nome do Arquivo }

Exemplo:

MORE TESTE.TXT

6.2.1.11 Comando COPY O comando COPY copia um determinado arquivo ou o disco inteiro, sendo que caso exista algum arquivo no destino com o mesmo nome do arquivo de origem, esse arquivo será substituído.

O COPY deve ser usado da seguinte maneira: copy [drive:\][caminho\] arquivo(s) de destino [opções] (Sem colchetes), sendo que não é obrigatoria a utilização das opções.

Opções: /v - Verifica o arquivo de destino após a cópia, esta opção deixa o copy mais lento.




/a - Indica um arquivo de texto ASCII.

/b - Indica um arquivo binário.

/d - Permite que o arquivo de destino seja criado descriptografado.

/n - Usa um nome de arquivo curto (Padrão 8.3), caso copie um arquivo fora deste padrão.

/y - Não pede confirmação para que você substitua um arquivo de destino já existente.

/-y - Pede confirmação para que você substitua um arquivo de destino já existente.

/z - Copia arquivos de rede no modo reiniciável.

Neste comando utiliza-se muito os caracteres "curingas" que têm a função de substituir qualquer caracter ou grupos de caracteres dependendo do curinga.

Os caracteres curingas são representados abaixo de acordo com a sua finalidade.

* - para uma quantidade de caracteres variante. ? - para um caracter

C:\>COPY C:\DOS\S*.* C:\AULA , faz a cópia de todos os arquivos que têm o nome que se inicia com a letra S do diretório de origem C:\DOS para o diretório de destino C:\AULA

C:\>COPY C:\DOS\VENDAS?.DOC C:\AULA , faz cópia de todos os arquivos que têm o VENDAS + 1 CARACTER

( ex: VENDAS1.DOC, VENDASX .DOC, etc.) do diretório de origem C:\DOS para o diretório destino C:\AULA

6.2.2 Comandos externos do MS-DOS Os comandos externos são programas utilitários que acompanham o sistema operacional e que só podem ser executados onde estão localizados, ou seja, no drive onde foram gravados. Assim como nos comandos internos pode-se usar o comando auxiliar /?.

6.2.2.1 Comando DISKCOPY Quando necessitamos fazer uma cópia das informações de um disquete, podemos utilizar o comandos Diskcopy. Este comando faz a duplicação de um disco, sendo que os dois discos devem possuir o mesmo tamanho e capacidade. Este comando só permite a duplicação de discos flexíveis. Este comando pode conter alguns argumentos para obter-se uma resposta diferente.

/V - Faz a verificação durante a duplicação do disco

Sintaxe: DISKCOPY [unidade:] [unidade:] /V

Exemplo:

C:\>DISKCOPY A: B: , faz a duplicação de um disco na unidade A: para unidade B:, sendo que os dois discos devem possuir o mesmo tamanho e capacidade




6.2.2.2 Comando XCOPY Comando que copia arquivos seletivamente, lendo em sub-diretórios diferentes na origem e podendo criar os sub-diretórios na unidade de destino, se assim for desejado.

Este comando pode conter alguns argumentos para obter-se uma resposta diferente. ORIGEM Drive, caminho e nome dos arquivos de origem

DESTINO Drive, caminho e nome dos arquivos de destino

/M - Copia os arquivos de origem e os "marca".

/D: - data Copia os arquivos de origem que foram modificados na data definida em "data"ou depois dela, (mm,dd,yy é o formato default")

/S - Copia os arquivos em diretórios e sub-diretórios, a não ser que estejam vazios

/E - Copia os subdiretórios mesmo que estejam vazios

Sintaxe: XCOPY [ ORIGEM] [DESTINO] /M /D:data /S /E /V

Exemplo:

C:\>XCOPY C:\DOS A: , copia o diretório DOS para o drive A:

6.2.2.3 Comando ATTRIB O Attrib altera ou mostra os atributos de um arquivo, devendo ser usado da seguinte maneira: attrib [Atributo] [drive:\][caminho\] nome do(s) arquivo(s) [opções] (Sem colchetes), sendo que não é necessária a utilização de opções caso você não queira.

Opções do "Atributo" dos colchetes:

+ - Ativa um atributo.

- - Desativa um atributo.

r - Atributo de arquivo somente leitura.

a - Atributo de arquivo de leitura/gravação.

s - Atributo de arquivo de sistema.

h - Atributo de arquivo oculto.

Opções: /s - Processa os arquivos da pasta atual.

/d - Inclui pastas.

6.2.2.4 Comando TREE Comando que exibe graficamente a árvore de diretórios e subdiretórios a partir do diretório-raiz para que o usuário tenha a organização hierarquia do seu disco. Este comando pode conter algumas variações para obter-se um resultado diferente:

/F - Exibe a árvore de subdiretórios, mostrando também os arquivos existentes dentro dele.




/A - Instrui o comando TREE a usar os caracteres gráficos disponíveis em todas as páginas de código e permite um processo de impressão mais rápido.

Sintaxe: tree [drive:\][caminho\][opções]

Exemplo:

C:\>TREE

C:\>TREE /F

C:\>TREE /A

6.2.2.5 Comando MOVE Comando que tem duas funções: Renomear diretórios ou mover arquivos de um diretório para outro: Sintaxe: MOVE [unidade:] [caminho] [nome antigo] [nome novo] ou [Origem] [Destino] Opções: /y - Não pede confirmação para a mudança dos arquivos.

/-y - Pede confirmação para mudança dos arquivos. Exemplos: C:\>MOVE C:\AULA C:\TESTE - renomeia o diretório C:\AULA para C:\TESTE C:\>MOVE C:\AULA*.* A:\ - faz a movimentação de todos os arquivos do drive de origem C:\AULA para o drive de destino A:\, deixando assim o diretório C:\AULA vazio.




6.2.3 Formatando disquetes e Discos Rígidos, apagando arquivos, e diretórios com conteúdo dentro.

Atenção: Os comando estudados abaixo só poderão ser executados nos

laboratórios do colégio com supervisão ou autorização explícita do

professor ou monitor responsável.

6.2.3.1 Comando FORMAT Antes de utilizar ou reutilizar um disco novo, você precisa prepará-lo para receber as informações e, essa preparação do disco é chamada de formatação, que tem a função de redefinir trilhas e setores na superfície magnética do disco. Num disco formatado podemos copiar um arquivo, um diretório de vários arquivos ou até um disco inteiro. A formatação deve ser aplicada com cuidado pois destrói o conteúdo anterior do disco. Este comando pode conter algumas variações para obter-se uma resposta diferente:

Sintaxe: FORMAT [unidade:] /Q /U /S /4

Opções:

/S - Formata o disco na unidade especificada e insere o Sistema Operacional DOS

/4 - Formata o disquete de baixa densidade em drives de alta densidade

/Q - Formata rapidamente o disco da unidade (Formatação Rápida)

/U - Formata o disco da unidade independente da condição (UNCONDICIONABLE)

Exemplo:

C:\>FORMAT A: - formata o disco na unidade A:

ATENÇÃO: tenha cuidado nas formatações de discos ,pois elas fazem com que o conteúdo do disco seja perdido. Vale lembrar que esta operação se torna muito mais crítica quando estamos formatando a unidade C ( FORMAT C:\ ), operação não indicada para pessoas com pouco conhecimento no assunto.

6.2.3.2 Comando DEL ou ERASE Apaga arquivos do disco rígido e deve ser usado da seguinte maneira: del [drive:\][caminho\] nome do(s) arquivo(s) [opções] (Sem colchetes), sendo que não é necessária a utilização das opções caso você não queira.

Sintaxe: DEL [unidade] [caminho] { Nome do Arquivo }

Opções:

/p - Força a mensagem de confirmação "Apagar( S / N )?".

/f - Força a exclusão de arquivos somente leitura.

/s - Exclui arquivos de todas as subpastas.

/q - Modo silencioso, não pede confirmação para excluir um caractere curinga global.

/a:atributo - Exclui somente arquivos de determinado atributo, onde atributo deve ser




substituído por algum desses caracteres e não devem ser digitados os 2 pontos (:).

S - Arquivos de sistema. R - Arquivos somente leitura.

H - Arquivos ocultos.

A - Arquivos prontos para arquivamento.

Obs.: Para reverter o efeito dos caracteres, é necessário a colocação de um hífen (-).

Ex.: Del *.* /a-h, executando este comando, você exclui todos os arquivos menos os arquivos ocultos da pasta.

6.2.3.3 Comando TREE É a combinação dos comandos del e tree: ele exclui arquivos de uma pasta suas subpastas e "subarquivos". Deve ser usado da seguinte maneira: deltree [opções][drive:\][caminho\] (Sem colchetes), sendo que não é necessária a utilização de opções caso você não queira.

Comando que apaga um ou mais subdiretórios do disco a partir do diretório corrente:

O comando deltree apaga todos os arquivos e subdiretórios dentro de um diretório de uma só vez. Como precaução ele sempre exibirá uma mensagem na tela perguntando se você realmente deseja apagar.

Opções:

/y - Não pede confirmação para a exclusão dos arquivos.

Exemplo:

C:\>DELTREE PROFESSOR

Utilizando-se deste comando o usuário poderá apagar subdiretórios com mais rapidez e eficiência.




7 Arquivo .BAT ( LOTE / BATCH). A sigla BAT é uma extensão de arquivo muito utilizada no MS-DOS e outros sistemas da microsoft, provem da palavra BATCH que em inglês significa LOTE.

Os programas ou arquivos feitos para rodarem como LOTE, funcionam da mesma forma ou que funcionavam os processos nos primeiros computadores, todos os comandos colocados nestes arquivos serão e são executados de forma seqüencial.

7.1 Para que serve um arquivo .BAT?

Como um arquivo .BAT, você pode automatizar processos em sua maquina como:

• Limpeza de arquivos temporários.

• Copias de segurança.

• Execução de programas

• Enviar e receber parâmetros para determinadas tarefas.

7.2 Comandos de arquivos .BAT

7.2.1 Comando ECHO Exibe mensagens ou ativa ou desativa a exibição do comando.

@ECHO [ON | OFF] – Dezativa a exibição de comandos na tela ECHO [mensagem] - Envia mensagem para tela ECHO. - Cria uma linha em branco.

Exemplo:

Quando quiser mandar uma mensagem para a tela, utilize o comando como mostrado abaixo:

ECHO OLA MUNDO!

7.2.2 Comando GOTO O comando GOTO direciona a leitura de um programa para uma determinada área demarcada, o comando é demonstrado abaixo

goto nome - direciona a "leitura" para o parágrafo nome.

Para que o comando GOTO funcione corretamente é necessário a criação de áreas demarcas ou parágrafos de orientação, e estes são criados como mostrado abaixo:

:nome - cria um parágrafo de orientação chamado nome.

7.2.3 Comando CALL Durante a execução de um arquivo de lote, quando o sistema se depara com o comando CALL ele automaticamente chama e executa um outro arquivo de lote.

call arquivo - chama um arquivo de lote do MS-DOS.




7.2.4 Comando START O comando START inicia qualquer aplicação do Windows no decorres da execução de um aequivo de lote.

start arquivo - inicia uma aplicação do Windows

7.2.5 Comando choice [texto] [opções] É utilizado em programas bat para dar ao usuario um conjunto de opções. Exemplo: CHOICE /c123456789

Opções:

CHOICE – Habilita apenas resposta S/N

CHOICE /c – Habilita a escolha de varias opções como: 1 , 2 , 3 , 4 , 5 .....

O comando CHOICE tem que vir sempre acompanhado do IF e ERRORLEVEL. IF e ERRORLEVEL são um complemento usado pelo CHOICE

Comando que possibilita o desenvolvimento de questões e respostas para o usuário Os comandos CHOICE e IF ERRORLEVEL são comandos que trabalham sempre em conjunto.

Exemplo:

@echo off cls echo Para qual time você torce? echo Responda a pergunta. echo --------------------------------------------------- Echo [1] Cruzeiro Echo [2] Atlético MG Echo [3] Ipatinga choice /c123 echo --------------------------------------------------- if errorlevel 3 goto END if errorlevel 2 goto END if errorlevel 1 goto END

Este programa cria as opções, mas quando estas são selecionadas o programa simplesmente termina pois no comando GOTO exite a palavra END. A posição do string sempre vem do maior para o menor. 3 , 2 e 1




8 Bibliografia Apostilas e Materiais Publicados: Prof. Cássio Mendes Baraky – Apostila de Sistemas Operacionais e Historia de Informática. Prof. Carlos Henrique Gremmelmaier - Material em PDF Prof. Carlos Alberto Maziero – Site: http://www.ppgia.pucpr.br/_maziero Livros: AbrahamSilberschatz, PeterGalvin, andGregGane. SistemasOperacionais – Conceitos e Aplicações. Campus, 2001. Davis, William S., Sistemas Operacionais - Uma Visão Sistemática, Ed. Campus, 1990. PPGIA CCET PUCPR Sites da Internet http://www.algosobre.com.br http://www.cultura.ufpa.br/dicas/progra/arq-uni.htm Wikimedia Foundation. Wikipedia online enciclopedia. http://www.wikipedia.org, 2005. _Copyright (c) 2008 CÁSSIO MENDES BARAKY. É garantida a permissão para copiar, distribuir e/ou modificar este documento sob os termos da Licença de Documentação Livre GNU (GNU Free Documentation License), Versão 1.2 ou qualquer versão posterior publicada pela Free Software Foundation. A licença está disponível em http://www.gnu.org/licenses/gfdl.txt.

Apostila de: Gestão de Sistemas Operacionais – I ( G.S.O – I ) · G.S.O – I – Gestão de...

Documents

Transcript of Apostila de: Gestão de Sistemas Operacionais – I ( G.S.O – I ) · G.S.O – I – Gestão de...