SISTEMAS OPERACIONAIS

SISTEMAS OPERACIONAIS

1. KERNEL

   • MONOTILICO
     • todos os módulos são executados em um mesmo espaço de endereçamento, se houver ocorrência de erro em um desses espaços, todo o sistema pode ser afetado
     • Há um único arquivo objeto, sendo que toda rotina fica visível às demais
     • linux
     • BSD
     • MS-DOS
   • MicroKernel
     • é um núcleo de tamanho bastante reduzido e, por esse motivo, ele executa o mínimo de processos possível no espaço do Kernel. Alguns desses processos são executados no espaço do usuário. Com um kernel micronúcleo, se ocorrer um erro, basta reiniciar o serviço que apresentou o problema. Com isso, evita-se que todo o sistema seja derrubado (como ocorre com o Kernel monolítico). Alguns exemplos: AIX, Minix e GNU Hurd.
     • AIX, MINIX, GNU HURD
   • Hibrido
     • funciona como um meio-termo, se comparado a sistemas monolíticos e de micronúcleos. O híbrido combina a estabilidade e a segurança do microkernel com o desempenho do monolítico. O kernel híbrido é semelhante a um micronúcleo, mas tem um código (“não essencial”) no espaço do núcleo para que as operações executadas sejam mais rápidas. Alguns exemplos: AmigaOS, Android, Macintosh e Windows.
     • WINDOWS
     • Android
     • MACintosh
   • Sistemas exonucleos
     • é um núcleo de tamanho bastante reduzido e, por esse motivo, ele executa o mínimo de processos possível no espaço do Kernel. Alguns desses processos são executados no espaço do usuário. Com um kernel micronúcleo, se ocorrer um erro, basta reiniciar o serviço que apresentou o problema. Com isso, evita-se que todo o sistema seja derrubado (como ocorre com o Kernel monolítico). Alguns exemplos: AIX, Minix e GNU Hurd.
   • Sistema em Camadas
   • Maquinas Virtuais
   • modelos cliente-servidor
   • modo kernel
     • uma aplicação pode executar instruções não privilegiadas e privilegiadas, ou seja: instruções que oferecem risco ao sistema, ex.: instruções que acessam dados no disco.

2. GERENCIA

   • De uma forma bem específica, encontramos na literatura especializada quatro tipos de gerenciamento realizados por um S.O.: • Gerência de processos (unidade básica de trabalho do sistema operacional), o que inclui a sua criação, sua exclusão e o fornecimento de mecanismos para a sua comunicação e sincronização; • Gerência de memória, controlando que partes estão sendo usadas e por quem. Além disso, é responsável pela alocação e liberação dinâmica de seu espaço; • Gerência de dispositivos de entrada/saída (E/S) ligados ao computador, o que inclui o envio de sinais que informam as ações que o usuário espera que o dispositivo realize, o tratamento das interrupções e erros gerados pelos dispositivos, entre outros;
   • Gerência de armazenamento, que inclui o fornecimento do sistema de arquivos para a representação de arquivos e diretórios e o gerenciamento do espaço em dispositivos de armazenamento de dados (HD, SSD, pen drive, entre outros).
   • PROCESSOS
     • o que é processo? É simplesmente um programa em execução, incluindo os valores correntes dos registradores (PC, IR, entre outros) e das variáveis (ex.: soma, total, em um programa que realiza cálculos).
     • Geralmente as informações contidas em um PCB incluem: • Identificador do processo (PID); -Registradores da CPU; • O espaço de endereçamento do processo; • Prioridade do processo; • Entre outras.
     • TROCA DE CONTEXTO
       • Quando a CPU muda o processo
       • Contexto de software: informações como nome do processo, identificador (PID), proprietário (owner - UID), prioridade de execução, entre outros; • Contexto de hardware: valores de registradores; • Espaço de endereçamento: espaço reservado para os dados do processo (ex.: texto editado através do Word)
       • PCB
         • Bloco de Controle do Processo (PCB - Proccess Control Block)
       • TABELA DE PROCESSOS
         • estrutura de dados responsável por habilitar o sistema operacional a localizar e acessar rapidamente o bloco de controle de processo (PCB) de um processo
     • CRIAR
       • Existem quatro eventos principais que acarretam a criação de processos, a saber: • Inicialização do sistema; • Realização de uma chamada de sistema por um processo em execução para a criação de um processo, ex.: fork() no Linux; • Um pedido de um usuário para a criação de um novo processo, ex.: clicar duas vezes para abrir um documento do Word; • Início de uma tarefa em lote (computadores de grande porte).
       • INICIAR S.O
       • fork() por um processo
       • comando do usuario
       • tarefa em lote
     • ESTADOS:
       • EM EXECUÇAO
       • BLOQUEADO
         • (ou espera): incapaz de executar até que algum evento ocorra (ex.: terminar de receber os dados de um arquivo que está armazenado em um HD).
       • PRONTO
         • temporariamente parado, mas pronto (aguardando) para utilizar o processador; 
     • CONDIÇOES DE CORRIDA
       • alguns processos que trabalham juntos podem compartilhar algum armazenamento comum, ou seja, cada processo pode ler e escrever nesse local.
       • EXCLUSAO MUTUA
         • uma maneira de proibir que mais de um processo leia e modifique dados compartilhados ao mesmo tempo
         • SOLUÇAO
           • SEMAFORO
             • Semáforo: é um tipo de variável que pode ser verificada e alterada em instruções atômicas, ou seja, sem possibilidades de interrupções. Esse tipo de variável é empregado em tarefas como o compartilhamento de recursos entre processos.
             • É uma variável do tipo inteiro que possui o valor 0 quando não tem nenhum sinal a despertar, ou um valor positivo quando um ou mais sinais para despertar estiverem pendentes (usamos o termo “despertar”, pois um fluxo de execução é “colocado para dormir” quando tenta entrar em uma região crítica que já está ocupada).
             • Vamos imaginar a seguinte situação: há um semáforo que está com o valor 0, ou seja, já tem processo(s) ocupando a região crítica. Enquanto isso, outros 3 chegam a essa região e “tentam entrar”, ficando bloqueados. Ao sair da região crítica, é aplicada a operação up (valor do semáforo passa para 1) e um dos três processos pode entrar (aleatório, fila ou outra maneira de escolher). Quando tal processo entrar é aplicada a operação down (semáforo passa a ser 0). Resumindo: o valor do semáforo diz quantos processos podem entrar!
           • MUTEX
             • versão simplificada do semáforo, quando não for necessário "contar", utilizando-se apenas os estados “livre” ou “ocupado”. Consequentemente é necessário apenas um bit para representá-lo, mas na prática geralmente é utilizado um valor inteiro. Quando um processo precisa entrar na região crítica, ele chama mutex_lock, que será bem-sucedida se a região estiver livre. Caso contrário, o processo ficará bloqueado até que o processo que estiver na região crítica saia (mutex_unlock).
             • Mutexes são bons somente para gerenciar a exclusão mútua de algum recurso ou trecho de código compartilhado. 
       • SEÇAO CRITICA
         • REGIAO COMPARTILHADA DE MERORIA OU ARQUIVO ENTRE 2 OU MAIS PROCESSOS
     • ESCALONAMENTO
       • CONCEITOS
         • PREEMPÇAO
           • que é o ato do S.O. utilizar as interrupções do relógio para retirar a CPU do processo em execução.
           • NAO- PREEMPTIVOS
             • LOTE
               • FCFS
                 • First-Come First-Served (FCFS): o nome do algoritmo já diz tudo (“O primeiro a chegar é o primeiro a ser atendido”), ou seja, os processos recebem tempo de CPU na ordem em que solicitam.
                 • FIFO
                   • Em um algoritmo de escalonamento FIFO, os processos são executados na mesma ordem que chegam à fila. Quando um processo do tipo cpu-bound está na frente da fila, todos os processos devem esperá-lo terminar seu ciclo de processador
               • SJF
                 • Tarefa mais curta primeiro”): mais um não-preemptivo
               • PREEMPTIVOS
                 • SRT
                   • versão preemptiva do algoritmo SJF. Nesse algoritmo o escalonador sempre escolhe o job com tempo de execução mais curto (obviamente o tempo precisa ser conhecido previamente)
         • STARVATION
           • processo que nunca consegue chegar ao processador, fica eternamente aguardando
       • ALGORITMOS DE
         • INTERATIVO
           • TODOS SAO PREEMPTIVOS
           • ROUND-ROBIN
           • ESCALONAMENTO POR MULTIPLAS FILAS
             • O algoritmo de escalonamento de múltiplas filas atua com classes de prioridade
           • ESCALONAMENTO GARANTIDO
             • O escalonamento garantido é aquele que busca fazer promessas realistas aos usuários sobre o desempenho
           • ESCALONAMENTO POR SORTEIO
           • ESCALONAMENTO POR PRIORIDADE
         • TEMPO REAL
     • TERMINO
       • devido a alguma das seguintes situações: • Término normal (voluntário); • Término por erro (voluntário), ex.: divisão por zero; • Erro fatal (involuntário), ex.: programa recebe como parâmetro o nome de um arquivo que não existe; • Eliminado por outro processo (involuntário), ex.: comando kill (Linux).
     • CPU-BOUND
       • Processos que passam a maior parte computando (CPU-bound) tendem a ir poucas vezes para o estado bloqueado (ou talvez nunca!), pois utilizam muito o processador e quando a fatia de tempo termina vão para o estado “pronto”.
     • I/O BOUND
     • Threads
       • threads de um mesmo processo compartilham a mesma seção de código na memória.
       • usuario
         • Quando falamos em thread ao nível de usuário queremos dizer que o controle das threads, o escalonamento entre elas, fica a cargo do espaço do usuário
       • kernel
   • MEMORIA
     • memory leak
       • memory leak (vazamento de memória) que pode ocorrer em duas situações: 1. Blocos de memória estão alocados e disponíveis para serem utilizados pelo programa, mas não são acessíveis porque a aplicação não tem nenhum ponteiro apontando para essa área de memória. Ou seja, tais blocos de memória não podem ser utilizados nem pelo programa nem por outros processos (ficam alocados e sem acesso!); 2. Blocos de memória possuem dados que poderiam ser liberados por estarem inacessíveis e que, por algum “esquecimento”, ainda são referenciados no código. Ou seja, mesmo sem estarem sendo usados, não podem ser liberados.
     • apenas um processo pode ocupar uma partição.
     • GERENCIAMENTO DE MEMORIA
       • O componente central de um sistema operacional que determina o local da memória onde deverá ser colocado o código de um novo processo, lido de um arquivo previamente armazenado em um dispositivo de entrada e saída (HD, por exemplo) é denominado gerenciador de memória.
       • Swapping
         • Há momentos em que não há memória principal suficiente para todos os processos ativos, de maneira que os processos excedentes devem ser mantidos em disco e trazidos para a memória dinamicamente. Para isso pode ser usado uma das seguintes estratégias: • Swapping: traz cada processo em sua totalidade, executa-o por algum tempo e o coloca novamente no disco;
         • traz cada processo em sua totalidade, executa-o por algum tempo e o coloca novamente no disco;
         • Compactação de memória
           • move os processos “para baixo” quando há algum espaço livre, deixando a parte “de cima” sem fragmentos. Por exemplo, na parte (d) da figura os processos B e C seriam deslocados para baixo, “encostando” no S.O. Porém, essa técnica exige muito tempo de CPU e geralmente não é utilizada.
         • mapa de bits
           • a memória é dividida em unidades de alocação, desde um pequeno número de palavras até muitos Kilobytes (ex.: 4KB). Para cada unidade de alocação existe um bit no mapa de bits, que é 0 se a unidade estiver livre e 1 caso esteja ocupada (ou vice-versa, dependendo da implementação).
           • (a) um pedaço da memória contendo 4 processos (A, B, C e D). Observamos também quantas unidades de alocação cada processo ocupa: A = 5, B = 6, C = 3 e D = 6. Se a unidade de alocação tiver 4KB, por exemplo, o processo A teria o tamanho entre (16KB + 1 byte) e 20KB, pois não há garantia que o processo ocupará toda a última unidade de alocação (seria muita “sorte”); (b) um mapa de bits correspondente ao pedaço de memória mostrado em (a), ou seja, para cada unidade de alocação ocupada há um bit 1 e para cada unidade de alocação livre existe um bit 0. Você pode contar cinco bits 0 apenas, pois são correspondentes àqueles “quadrados pintados” e ainda pode ver que eles aparecem nas posições 6, 7, 8, 18 e 19. O resto das unidades de alocação está ocupado (bit 1); (c) uma lista encadeada reapresentando as mesmas informações mostradas no item (b), da seguinte forma: “P” representa que está ocupado por um processo, o campo seguinte informa a posição inicial, o seguinte a posição final e o último campo é um ponteiro para o próximo nodo da lista. Se estiver livre, no lugar “P” é colocado um “L”.
           • O problema principal do mapa de bits é que quando se decide trazer um processo de N unidades de alocação para a memória, o gerenciador de memória deve pesquisar no mapa de bits uma sequência de N bits 0 consecutivos no mapa. Tal operação é lenta, motivo pelo qual essa estratégia ser evitada na prática, mas...é cobrada em concurso!
         • Listas encadeadas
           • uma outra maneira de gerenciar a memória é manter uma lista de alocações e segmentos de memória livre, onde um segmento é um processo ou um espaço livre entre dois processos.
       • Memória virtual
         • os programas podem ser executados mesmo estando apenas parcialmente na memória principal.
         • O nome já é bem intuitivo: “memória virtual” é aquela que não é a real (física). Podemos ter uma memória virtual maior que a real e ocorre swapping entre a memória real e o disco. No fim o disco acaba sendo a extensão da memória real, para “fingir” que a memória é maior do que realmente é! Podemos, por exemplo, executar processos que totalizem 5GB com uma memória RAM de 4GB!
         • Memória virtual: os programas podem ser executados mesmo estando apenas parcialmente na memória principal. Note que a estratégia swapping transfere o processo por completo, enquanto a memória virtual permite partes.
         • Segmentação
           • os programas são divididos em segmentos de tamanhos diversos, cada um com o seu próprio espaço de endereçamento. A alocação da memória ocorre de maneira não fixa, ou seja, cada segmento pode ter um tamanho diferente (a alocação depende da lógica do programa). O mapeamento é feito através das tabelas de mapeamento de segmentos e os endereços são compostos pelo número do segmento e um deslocamento dentro do segmento (ex.: segmento 0, deslocamento = 500 bytes).
           • algoritmos
             • first-fit
               • procura ao longo da lista de segmentos até encontrar um espaço livre de tamanho maior ou igual a N. Caso o espaço livre seja maior que N, o espaço livre é quebrado em dois segmentos: um para o processo (N bytes) e o outro para a memória que não foi utilizada. É um algoritmo rápido pois termina a busca o mais cedo possível.
             • Next-fit
               • funciona da mesma forma que o First-fit, com uma exceção: guarda a posição da lista onde o último espaço livre foi alocado. Quando for chamado novamente, o algoritmo começa a procurar a partir desse ponto.
             • Best-Fit
               • procura pela lista inteira e “pega” o espaço livre de tamanho mais próximo de N. É lento e cria na memória espaços livres pequenos que dificilmente serão alocados. Porém, para N grande, esse algoritmo aumenta as chances de se encontrar na lista um espaço livre de tamanho adequado, visto que minimiza o uso espaços livres grandes para atender requisições pequenas.
             • quick-fit
               • mantém listas separadas para tamanhos comumente solicitados, como por exemplo: uma lista para espaços livres de tamanho 4KB, outra para espaços de 8KB, e assim sucessivamente. Com esse algoritmo encontra-se um espaço livre de tamanho requerido muito rapidamente, mas com a desvantagem de todos os esquemas de classificar os espaços livres por tamanho. Ou seja, quando um processo termina ou é permutado para o disco, determinar seus vizinhos para uma possível fusão é uma operação custosa. Se fusões não forem realizadas, a memória rapidamente se fragmentará em um grande número de pequenos espaços livres não utilizáveis.
         • Paginação
           • técnica utilizada pela maioria dos sistemas com memória virtual. Em qualquer computador existe um determinado conjunto de endereços de memória que programas podem referenciar. Trata-se de endereços virtuais que formam o espaço virtual de endereçamento do processo. Em computadores sem memória virtual, o endereço virtual é colocado diretamente no barramento de memória uma palavra da memória física com mesmo endereço é lida ou escrita. Com o uso da memória virtual, os endereços de memória não vão diretamente para o barramento de memória, eles vão à unidade de gerenciamento de memória (MMU - Memory Management Unit), um hardware específico que mapeia os endereços virtuais em endereços da memória física
           • O espaço de endereçamento virtual é dividido em unidades chamadas páginas. As unidades correspondentes na memória física são chamadas quadros (page frames). Para não ter erro pense no seguinte: uma página deve ser “encaixada” em um quadro, uma “moldura física”. Assim fica mais fácil para não se confundir.
           • As páginas e quadros são sempre do mesmo tamanho
           • Como as páginas são do mesmo tamanho (ex.: 4KB), é muito provável que a última página de um processo tenha um espaço não utilizado. Imagine um processo com tamanho 9KB, ele precisa de 3 páginas (2 “completas” + 1 usando apenas 1KB dos 4KB). Isso é conhecido como fragmentação interna, pois existem as páginas de tamanho fixo e algumas ficarão sem ser preenchidas (e nenhum outro processo pode utilizá-las).
           • A falta de página é corrigida com a carga da página em falta, da memória virtual para a memória física.
           • Há quatro momentos em que o sistema operacional tem de se envolver com a paginação: na criação do processo, na execução do processo, em faltas de páginas e no término do processo. 
           • algoritmos
             • ótimo
               • quando ocorre uma falta de página, um determinado conjunto de páginas está na memória. Uma dessas páginas será referenciada em muitas das próximas instruções. Outras páginas não serão referenciadas  antes de 10, 100, ou quem sabe 1000 instruções. Cada página pode ser “marcada” com o número de  instruções que serão executadas antes que a página seja inicialmente referenciada. O algoritmo simplesmente diz que a página com o maior rótulo deve ser removida, adiando-se o  máximo possível a próxima falta de página. O único problema é que ele não é realizável. No momento da falta de página, o sistema operacional não tem como saber quando cada página será referenciada
             • NRU - NOT RESENTLY USED
               • “Não Recentemente Usada”: para que o S.O. saiba quais páginas são e quais não  são utilizadas recentemente, muitos computadores com memória virtual possuem 2 bits associados à cada página. Um bit R (Referência) é ativado pelo hardware em qualquer leitura ou escrita de página, ou seja, se  houve uma referência, marca com o bit 1. O outro bit, M (Modificação), é ativado pelo hardware quando  uma página é escrita (modificada). É importante que esses bits sejam atualizados em qualquer referência de memória, assim, é essencial que eles sejam ativados pelo hardware. Uma vez que um bit foi ativado, ele permanece ativado até que o sistema operacional o desative (por software).
               • Quando uma falta de página ocorre, o S.O. verifica todas as páginas e as classifica em 4 categorias baseado nos valores correntes de seus bits R e M: • Classe 0: não referenciada, não modificada; • Classe 1: não referenciada, modificada; • Classe 2: referenciada, não modificada; • Classe 3: referenciada, modificada. Interrupções de relógio não zeram o bit M porque essa informação é necessária para determinar se uma página terá que ser reescrita no disco ou não. O algoritmo NRU remove uma página aleatória da classe não vazia de numeração mais baixa (classe 0).
             • LRU - LEAST RECENTLY USED
               • “Menos Usada Recentemente”: quando ocorre uma falta de página, retira-se a página que não tem sido usada por um tempo longo. É um algoritmo teoricamente realizável, porém seu custo é alto. Para sua implementação completa, é necessário manter uma lista encadeada de todas as páginas em memória, com a página mais recentemente usada no início e a menos recentemente usada no fim. A dificuldade é que a lista deve ser atualizada em toda referência (leitura ou escrita) de memória. Encontrar a página na lista, removê-la de sua posição atual e movê-la para o início representa um grande esforço computacional!
             • FIFO
               • (First In, First Out): o S.O. mantém uma lista de todas as páginas correntes na memória, sendo a página da “cabeça” da lista a mais antiga e a página do fim a carregada mais recentemente. Em uma falta de página, a página da cabeça é removida e a nova página carregada é acrescentada no fim da lista. É a tradicional fila que estamos acostumados em diversas situações na vida!
             • SEGUNDA CHANCE
               • no algoritmo FIFO pode ocorrer de uma página muito utilizada ser retirada, pois sua vez chegou no andamento da fila! Para dar uma “segunda chance” existe uma variação em relação ao FIFO. A ideia é que primeiro seja examinada a página mais antiga como uma candidata a ser removida. Se seu bit R (Referência) for 0, a página é trocada imediatamente. Se o bit R for 1, o bit é zerado e a página é colocada no fim da lista de páginas (essa é a segunda chance da página!). Dessa forma a pesquisa continua. Resumindo: O algoritmo segunda chance busca por uma página antiga que não tem sido referenciada na interrupção de relógio anterior.
             • RELÓGIO
               • utiliza uma lista ordenada de forma circular tal como um relógio. O ponteiro do relógio aponta para a página mais antiga e assim que ocorrer uma falta a página mais antiga é verificada. Se o bit R dessa página for 0 ela é substituída, caso contrário esse bit é zerado e o ponteiro aponta para a próxima página mais antiga. Esse processo é então repetido até a próxima página com o bit R=0 ser encontrada
     • OVERLAY
       • Um fato notório na evolução da informática é que o tamanho dos programas vem superando a quantidade de memória disponível para carregá-los. Uma solução que geralmente era adotada no passado era a divisão do programa em partes (overlays). O overlay 0 começa a ser executado primeiro. Quando finaliza, o próximo overlay é executado, e assim sucessivamente. Os overlays eram mantidos em disco e permutados para a memória pelo sistema operacional
   • I/O
     • Geralmente as unidades de E/S consistem em um componente mecânico e um eletrônico e é comum que estejam separadas em duas partes, o que permite um projeto mais modular. O componente eletrônico é o que chamamos de controladora ou o adaptador (pode ser uma placa ou “embutido” na placa-mãe, por exemplo).
     • bloco
       • HDs que tem blocos de dados geralmente de 512bytes
     • caracter
       • teclados, mouses, impressoras...
     • tecnicas de gerenciamento
       • E/S mapeada em memória
         • processador controla operaçao de e/s e é preciso esperar que a operaçao termine
         • cada controladora possui registradores (memória) utilizados para se comunicar com o processador.
       • interrupçoes
         • processador controla a operaçao de E/S e pode realizar outras tarefas ao mesmo tempo
         • forma de avisar a CPU que os registradores estão prontos para serem lidos ou escritos.
       • DMA: Direc Acess Memory
         • SEM ENVOLVIMENTO DO PROCESSADOR PROCESSADOR pode executar outras taregas enquanto o modulo de e/s executa seu trabalho 
   • ARMAZENAMENTO
     • SISTEMAS DE ARQUIVOS
       • Para criar, abrir, manipular, fechar, excluir arquivos, entre outras operações, são utilizadas chamadas de sistema
       • MS-DOS
         • FAT-16
         • FAT-32
         • FAT 12
       • WINDOWS
         • FAMILY FAT
         • NTFS
         • DLL
           • biblioteca que contém código e dados que podem ser usados por mais de um programa ao mesmo tempo no Windows. 
         • ReFS
           • (Sistema de Arquivos Resiliente) é o sistema de arquivos mais recente da Microsoft, projetado para maximizar a disponibilidade de dados, dimensionar com eficiência para grandes conjuntos de dados em diferentes cargas de trabalho e fornecer integridade de dados com resiliência a corrupção. Ele procura lidar com um conjunto crescente de cenários de armazenamento e estabelecer uma base para inovações futuras. O ReFS introduz novos recursos que podem detectar precisamente danos e também corrigir esses danos enquanto permanece online, proporcionando maior integridade e a disponibilidade para seus dados.
       • LINUX
         • EXT
       • MBR
         • O setor 0 do disco é chamado MBR (Master Boot Record) e é utilizado para inicializar o computador. No final do MBR existe uma tabela de partições, contendo os endereços inicial e final de cada partição.
         • Quando o computador é inicializado, a BIOS lê e executa o código que está na MBR, localiza a partição ativa, lê o seu primeiro bloco (bloco de inicialização) e o executa. O
       • JOURNALING
         • Trata-se do registro das atividades que o sistema de arquivos irá fazer antes que efetivamente o faça. Mas para que isso? Simples...se o sistema falhar antes da execução do trabalho planejado, é possível, após a reinicialização do sistema, recorrer ao log para descobrir o que estava acontecendo no momento da parada e retomar o trabalho
         • Dos sistemas de arquivos mais conhecidos é importante sabermos quais deles possuem ou não a implementação de journaling: • FAT12, FAT16, FAT32: NÃO possuem journaling; • NTFS: possui journaling; • EXT2: NÃO possui journaling; • EXT3, EXT4: possuem journaling.
       • sun microsystem
         • ZFS
           • O ZFS é um sistema de arquivos e gerenciador de volumes lógicos combinados projetado pela Sun Microsystems. Os recursos do ZFS incluem proteção contra corrupção de dados, suporte para altas capacidades de armazenamento, compactação de dados eficiente, integração dos conceitos de sistema de arquivos e gerenciamento de volume, instantâneos e clones de cópia em gravação, verificação de integridade contínua e reparo automático, RAID-Z e ACLs NFSv4 nativas.
       • DIRETORIOS
         •  Diretórios: Para controlar os arquivos, sistemas de arquivos normalmente têm diretórios ou pastas, que são em si arquivos.
         • NO FIM É TUDO ARQUIVO QUE REFERENCIA OUTROS ARQUIVOS
     • implementação do armazenamento dos arquivos
       • alocação contígua
         • armazena cada arquivo como uma sequência contígua de blocos. Se uma partição foi formatada com blocos de tamanho 4KB, um arquivo de 40KB deve alocar 10 blocos consecutivos. Como vantagens temos a simplicidade na implementação (basta saber o bloco de início e o de fim do arquivo), e o desempenho na leitura (o arquivo inteiro pode ser lido em uma única operação).
       • alocaçao encadeada
         • cada arquivo é mantido como uma lista encadeada de blocos de disco, como mostrado na figura abaixo. Dessa forma todos os blocos podem ser utilizados! Além disso, é suficiente que a entrada de diretórios armazene apenas o endereço de disco do primeiro bloco e o restante pode ser encontrado a partir dele.
       • Alocação encadeada com tabela na memória:
         • no lugar de utilizar um ponteiro em cada bloco para apontar para o próximo, é utilizada uma tabela. Assim os blocos possuem um tamanho múltiplo de 2, o que facilita a vida do sistema de arquivos. Para definir o fim do arquivo deve-se utilizar um marcador especial, como por exemplo “-1”. Essa tabela é chamada de FAT (File Alocation Table - Tabela de Alocação de Arquivo)
         • A principal desvantagem é que a tabela inteira deve estar em memória, o que pode demandar de boa quantidade de espaço. Vamos a um exemplo: disco de 500GB, com tamanho de bloco 1KB (coloquei pequeno assim para facilitar o cálculo), a tabela precisa de 500 milhões de entradas (uma para cada bloco)! Cada entrada deve ter no mínimo 3 bytes para manter os endereços dos blocos, mas para facilitar a pesquisa as entradas possuem 4 bytes. Vamos ao cálculo: 500 milhões x 4 bytes = 2 bilhões (2 GB). Se o bloco tiver 4 KB, seria uma tabela de 500 MB.
       • I-nodes
         • cada arquivo é associado a uma estrutura de dados denominada i-node (nó-índice),
   • I/O
     • Geralmente as unidades de E/S consistem em um componente mecânico e um eletrônico e é comum que estejam separadas em duas partes, o que permite um projeto mais modular. O componente eletrônico é o que chamamos de controladora ou o adaptador (pode ser uma placa ou “embutido” na placa-mãe, por exemplo). A controladora normalmente possui algum conector que permite a conexão com o dispositivo em si.
     • DISPOSITIVOS DE BLOCO
       • armazena informações em blocos de tamanho fixo (ex.: 512 bytes, 32KB, entre outros). É possível ler ou escrever cada bloco, independentemente dos outros e o principal exemplo são os discos. O sistema de arquivos trata somente com os dispositivos de bloco abstratos e a parte mais “baixo nível” fica sob a responsabilidade de um software denominado driver de dispositivo
     • DISPOSIVIVOS DE CARACTERE
       • O dispositivo de caractere envia ou aceita um fluxo de caracteres, sem nenhuma estrutura de bloco. Ele não tem endereços (como ocorre com os blocos) e não possui operações de busca. Alguns exemplos são as impressoras, interfaces de rede e mouses.
     • Técnicas de Gerenciamento I/O
       • E/S mapeada em memória
         • cada controladora possui registradores (memória) utilizados para se comunicar com o processador. O sistema operacional escreve nesses registradores, “avisando” para o dispositivo enviar dados, aceitar dados, ligar-se ou desligar-se, etc. Note que a forma de comunicação é através da escrita em registradores. Lendo esses registradores, o S.O. pode saber qual o estado do dispositivo (ex.: pronto para aceitar um novo comando). Geralmente os registradores das controladoras possuem bits de status que devem ser testados com a intenção de saber se uma operação de saída está concluída ou se novos dados estão disponíveis em um dispositivo de entrada. Para realizar essa consulta a CPU pode executar um laço para consultar os bits de status, o que é chamado de E/S programada, consulta sequencial (polling) ou espera ativa (busy wait).
       • Interrupções
         • outra forma de avisar a CPU que os registradores estão prontos para serem lidos ou escritos. A maioria dos dispositivos de interface fornece uma saída logicamente igual ao bit de status “operação completa” ou “dados prontos” de um registrador, que é destinada a ser utilizada em uma das linhas de pedido de interrupção (IRQ – Interrupt ReQuest) do barramento do sistema. Mas o que é isso? Pense no seguinte: o dispositivo quer interromper o processador para que ele verifique o seu status e tome alguma atitude. Então, quando uma operação termina, ela envia uma interrupção ao processador, que começa a executar a rotina de tratamento da interrupção. Tal código informa ao S.O. que a E/S está concluída, então o S.O. pode verificar os bits de status para saber se tudo ocorreu bem (se não ocorreu, pode tentar novamente). Em sistemas antigos a IRQ era configurada por meio de chaves (jumpers), mas na atualidade a tecnologia Plug’n play já resolve isso de forma automática, evitando conflitos
       • Acesso direto à memória (DMA):
         • para deixar a CPU um pouco mais livre, um esquema denominado Direct Memory Access (DMA) é utilizado. Para isso deve haver uma controladora de DMA instalada (o que a maioria dos sistemas possui). Essa controladora pode estar integrada à controladora de disco ou separada. O mais comum é haver uma única controladora de DMA na placa-mãe para controlar as transferências dos diversos dispositivos de E/S. Não importa a localização física da controladora de DMA, ela tem acesso ao barramento do sistema independentemente do processador

3. SHELL

   • um processo que lê o teclado e espera por comandos, interpreta-os e passa seus parâmetros ao S.O. Por isso também é conhecido como interpretador de comandos.

4. DEADLOCK

   • MUTUAL EXCLUSION
     • cada recurso ou está correntemente atribuído a exatamente um processo ou está disponível.
   • MONOPOLIZAÇAO DE RECURSOS
   • NAO PREEMPÇAO
   • CIRCULAR WAIT
   • algoritmos de recuperaçao
     • avetruz
       • estratégia mais simples! O que um avestruz faz? Coloca a cabeça em um buraco... pois é, é isso mesmo! O algoritmo finge que nada aconteceu, simplesmente ignora. E, por incrível que pareça, é a estratégia adotada pela maioria dos sistemas operacionais (Windows, Linux, entre outros). Por quê? Porque o preço seria alto em realizar muitas restrições ao usuário. Melhor deixar acontecer...e se for o caso, o usuário reinicia a máquina ou mata um processo, caso ocorra algum travamento.
     • detecçao e recuperaçao
       • o sistema monitora as requisições e liberações de recursos. Sempre que um recurso é solicitado ou liberado, o grafo de recursos é atualizado e uma verificação para saber se há ciclos é realizada. Se houver um ciclo, um dos processos do ciclo é eliminado. Se não resolver o deadlock, outro será eliminado e assim por diante.
     • prevenção de impasses
       • estratégia que impõe restrições sobre os processos a fim de tornar os impasses impossíveis. As quatro condições que já vimos dão um indício de possíveis soluções.
     • evitar impasses
       • não há a imposição de regras, mas sim uma análise criteriosa de cada pedido de recurso. Para isso algumas informações devem estar disponíveis antecipadamente

5. Chamadas de sistema

   • (system calls) que são “instruções estendidas”, abstraindo do programador os detalhes de “baixo nível” e garantindo que o programador não faça alguma “bobagem”.
   • system call: é o mecanismo programático pelo qual um programa de computador solicita um serviço do núcleo do sistema operacional sobre o qual ele está sendo executado. As chamadas de sistema podem ser agrupadas, grosso modo, em seis categorias principais: Controle de processos Gerenciamento de arquivos Gerenciamento de dispositivos Manutenção de informações Comunicações Proteção

Bilder und Dateien der Mindmap