Trabalho sistemas operacionais - Chamadas de sistemas

Prévia do material em texto

CENTRO UNIVERSITARIO FUNDAÇÃO ASSIS GURGACZ
SISTEMAS OPERACIONAIS
CHAMADAS DE SISTEMAS 
CASCAVEL/PR
2019
SISTEMAS OPERACIONAIS
ADEMIR MAIANTE JUNIOR
CHAMADAS DE SISTEMAS 
Pesquisa sobre chamadas de sistemas, para disciplina de Sistemas Operacionais, do curso de Sistemas de Informação do Centro Universitário Assis Gurgacz. 
Professor: Elenilton
CASCAVEL/PR
2019
SUMÁRIO
INTRODUÇÃO	4
Chamadas de Sistemas	5
Chamadas de Sistema (System Calls) do Unix	10
Chamadas de Sistema (System Calls) do Windows	13
Gerenciamento de processos	15
Gerenciamento de Arquivos	22
Gerenciamento de Diretórios	23
Sinalização	25
Proteção	27
Gerenciamento de Tempo	30
CONCLUSÃO	32
REFERÊNCIAS	33
 
INTRODUÇÃO
O trabalho abordara o tema de chamadas de sistemas, o termo chamadas de sistema abrange uma grande área como por exemplo chamadas de gerenciamento de processos, sinalização, gerenciamento de arquivos, gerenciamento de diretórios, proteção, gerenciamento de tempo, e ao decorrer do trabalho será explicado e apresentado alguns exemplos sobre o tipo de cada uma das chamadas. 
As chamadas do sistema no Windows são usadas para controle do sistema de arquivos, controle de processos, comunicação entre processos, gerenciamento de memória principal, manipulação de dispositivos
As chamadas do sistema no Unix são usadas para controle do sistema de arquivos, controle de processos, comunicação entre processos, etc. O acesso ao kernel Unix está disponível apenas através dessas chamadas do sistema os processadores implementam uma instrução especial que permite acionar o mecanismo de interrupção de forma intencional, sem depender de eventos externos ou internos. Muitas chamadas de sistemas relacionam-se ao sistema de arquivos, para ler ou escrever um arquivo é necessário abri-lo, essa chamada de diretório é especifica para identificar o arquivo que será aberto. 
Chamadas de gerenciamento de diretórios se relaciona com mais diretórios ou sistema de arquivos como um todo, em vez de apenas um arquivo especifico como as chamadas anteriores.
Chamadas de Sistemas
Além de escalonar o uso do(s) processador(es) para a execução das instruções dos processos, o SO tem a função de prover serviços a esses processos. Serviços incluem o uso dos dispositivos de E/S, normalmente para gravar e recuperar dados de arquivos, para ler e escrever nos terminais de usuário, e para transmitir e receber dados através da rede de comunicação. Esses serviços do SO são providos para simplificar os códigos dos processos, que não precisam preocupar-se com os detalhes da operação dos dispositivos, e também para promover o compartilhamento ordenado do uso dos dispositivos. Há também serviços para o gerenciamento de processos e de threads e para a comunicação e sincronização de suas execuções. Outras tantas funcionalidades adicionais podem ser providas por um SO. Também elevam o privilégio de execução do processador Fig.1. (CRESTANA)
Fonte: (TANEMBAUM, 2016)
Figura 1 - Interface
Por questões de desempenho e facilidade de acesso, o código executado pelas chamadas de sistema está permanentemente residente na memória, pronto para ser usado por qualquer processo que as solicite. Para acessá-lo, normalmente é utilizado um mecanismo baseado em instruções de interrupção (INT), ou instruções específicas do processador para esse fim, como SYSCALL ou SYSENTER. Além de prover uma forma de localizar o código do SO na memória, sem saber previamente o endereço onde cada rotina foi posicionada, as instruções de acesso ao SO também elevam o privilégio de execução do processador. Em sistemas Linux, por exemplo, o acesso às chamadas de sistema é comumente feito usando uma chamada à instrução de interrupção para o número 80h (128) Fig.2. (CRESTANA)
Fonte: (CRESTANA, 2011)
Figura 2 - Chamadas de Rotinas
Para favorecer a portabilidade dos programas e facilitar as chamadas às rotinas, contudo, cada SO define um conjunto de funções em alguma linguagem de alto nível, como C. Cabe a essas funções de alto nível, então, fazer os ajustes necessários em registradores específicos do hardware e usar uma instrução de interrupção (INT), SYSCALL ,ou SYSENTER, para que o acesso efetivo ao código do SO seja realizado. Assim, não é preciso programar em baixo nível para fazer acesso às chamadas de sistema. E sistemas compatíveis com Unix, as chamadas de sistema são padronizadas Figura 2. (CRESTANA)
Fonte: (SILBERSCHATZ, 2009)
Figura 3 - Chamadas Especificas
E sistemas compatíveis com Unix, as chamadas de sistema são padronizadas. Há diversos padrões associados à Single Unix Specification [1], que definem também as chamadas de sistema que devem estar disponíveis. O mesmo tipo de chamadas de sistema está disponível para a plataforma dos SOs MacOS, que atendem às especificações POSIX, além de suas chamadas específicas. (CRESTANA)
Nos sistemas operacionais Microsoft, uma API chamada WinAPI (Windows API), anteriormente denominada Win32 API, define as chamadas de sistema disponíveis. Usando essa interface, é possível criar aplicações usando C/C++, .NET ou JavaScript. Embora essa API tenha milhares de funções, nem todas as chamadas disponíveis nessa API geram chamadas de sistema. Muitas delas são tratadas dentro do escopo do programa de usuário, como chamadas para gerenciamento de janelas e aspectos da interface gráfica. (CRESTANA)
Há diversos padrões associados à Single Unix Specification [1], que definem também as chamadas de sistema que devem estar disponíveis. O mesmo tipo de chamadas de sistema está disponível para a plataforma dos SOs MacOS, que atendem às especificações POSIX, além de suas chamadas específicas como podemos ver na Figura 5. (CRESTANA,2011)
Fonte: (SILBERSCHATZ, 2009)
Figura 4 - Chamada Especifica
Os sistemas operacionais contêm duas principais funções que são, fornece abstração para os programas de usuários e gerencias os recursos do computador. (TANEBAUM,2016)
Na maior parte do tempo o sistema operacional lida com a primeira função pois ela cria, escreve, realiza leitura e deleta arquivos, já a segunda, gerenciamento de arquivos age em transparência para os usuários e é feita automaticamente. (TANEBAUM,2016) 
Fonte:( (SILBERSCHATZ, 2009)
Figura 5 - Estrutura Unix
As chamadas de sistema variam de um sistema para outros embora os conceitos serem similares, o sistema operacionais possui chamada de sistema para ler arquivos , como por exemplo, sistema Unix, possui chamada READ com três parâmetros: um para especificar o arquivo, um para dizer onde os dados devem ser colocados e outro para dizer quantos bytes devem ser lidos Chamadas sistemas. (TANEBAUM,2016)
Para esclarece o mecanismo de chamada de sistema utilizaremos o comando read, ele possui três tipos de leituras, o primeiro especifica o arquivo o segundo e um ponteiro para o bugger e o terceiro e o número de bytes a ser lido. Como a maioria dos programas são em linguagem C é invocado uma biblioteca com o mesmo nome que a chamada de sistema. (TANEBAUM,2016)
contador = read (fd, buffer, nbytes) 
Se a chamada de sistema não for realizada devido algum parâmetro invalido o contador passa a valer -1 e o número de erro e colocado em uma variável global, Errno. A consulta é realizada em 11 passos. (TANEBAUM,2016) 
1- Empilha nbytes
2- Empilha &Buffer
3- Empilha FD
4- Chamada Read
5- Coloca o código para read no registrador
6- Armadilha para o núcleo
7- Despacho 
8- Executa o tratamento 
9- Tratador de chamada de sistema 
10- Retorna a quem chamou
11- Incrementa SP
Fonte: (TANEMBAUM,2016)
Figura 6 - Tratador de chamada
Chamadas de Sistema (System Calls) do Unix
As chamadas do sistema no Unix são usadas para controle do sistema de arquivos, controle de processos, comunicação entre processos, etc. O acesso ao kernel Unix está disponível apenas através dessas chamadas do sistema. Geralmente, as chamadas do sistema são semelhantes às chamadas de função, a única diferença é que elas removem o controle do processo do usuário. (FAINA,2002)
O escalonamento de processosno UNIX segue um algoritmo que combina prioridades e Round Robin. É necessário enfatizar que tal algoritmo tem o ob jetivo de compartilhar a CPU de forma equânime entre múltiplos usuários (sendo, portanto, orientada ao time-sharing). Tal algoritmo é inadequado para aplicações que requeiram o cumprimento estrito de restrições temporais, como impostas por aquelas denominadas de tempo real estritas (hard real-time). O núcleo divide os processos segundo duas classes de prioridades. (FAINA,2002)
Fonte: FAINA,2002
Figura 7 - Classes de propriedades
A Fig.7 mostra as classes de prioridades adotadas. Prioridades em modo núcleo são subdivididas em dois grupos. O primeiro grupo, de elevada prioridade, é constituído de processos bloqueados a espera de swapping, E/S em disco, buers de cache e inodes. Quando acordados, estes processos completam suas respectivas chamadas de sistema ininterruptamente (visando a rápida liberação de recursos do núcleo, tais como buers). O segundo grupo, de prioridade mais baixa que o primeiro, constitui-se de processos bloqueados a espera de entrada de terminal, saída em terminal e terminação de processo lho. Tais processos podem ser interrompidos, pois estes estados de bloqueio não demandam grandes recursos do núcleo. Finalmente, processos aguardando apenas CPU (estado 7) são dispostos segundo um certo número de níveis de prioridade (este número é dependente da particular implementação). Processos em uma mesma classe de prioridade são dispostos em uma la, como representado na Fig.7 pelos círculos interligados. O algoritmo de escalonamento do UNIX é processado segundo o seguinte esquema. Quando ocorre uma interrupção do hardware. (FAINA,2002)
pid = fork() - Essa chamada cria um processo (filho), idêntico ao pai
pid = waitpid(pid, &statloc, options) - O processo pai volta a rodar somente após o término do filho, ou seja, o processo pai aguarda o filho ser finalizado
s = execv(name, argv, enrionp) - É realizado, no processo, a substituição da imagem do núcleo
exit (num) - Termina um processo e retorna um status (um número identificado algo, como sucesso, erro etc)
fd = open (file, abertura ...) - Abre um arquivo (leitura, escrita ou os dois)
s = close(fd) - Fecha o arquivo anteriormente aberto 
n = read (fd, buffer, nbytes) - Lê dados do arquivo 'fd' no 'buffer’, de 'nbytes' valores de bytes
n = write(fd, buffer, nbytes) - Analogamente ao read, mas escreve
position = lseek(fd, offset, whence) - Move o ponteiro de 'fd'
s = stat(name, &buf) - Retornar informações do arquivo
s = chdir(nome) - Altera o diretório em que se está trabalhando
s = kill(pid, sinal) - Envia um sinal 'sinal' para o processo de PID 'pid'
seconds = time(&seconds) - Essa chamada retorna o tempo, em segundos, desde 1o de janeiro de 1970
s = chmod(nome, modo) - Altera o sistema de proteção do arquivo 'nome' 
s = mkdir(nome, modo) - Cria uma pasta (diretório)
s = rmdir(nome) - Apaga o diretório de nome "nome", previamente criado
s = mount(special, nome, flag) - Cria um sistema de arquivos (como um dvd ou pendrive)
s = umount(special) - Desmonta o sistema de arquivos previamente criado
s = link(nome1, nome2) - Cria a entrada 'nome2' apontando pra 'nome1'
s = unlink(nome) - Desfaz a entrada 'nome'
FAINA,2002
Figura 8 - Chamadas POSIX
Chamadas de Sistema (System Calls) do Windows
As chamadas do sistema no Windows são usadas para controle do sistema de arquivos, controle de processos, comunicação entre processos, gerenciamento de memória principal, manipulação de dispositivos de E / S, segurança etc. Os programas interagem com o sistema operacional Windows usando as chamadas do sistema. Como as chamadas do sistema são a única maneira de acessar o kernel, todos os programas que requerem recursos devem usar as chamadas do sistema. (CRESTANA,2011)
CreateProcess - fork
WaitForSingleObject - waipid
ExitProcess - exit
CreateFile - open
ReadFile - read
WriteFile - write
CloseHandle - close
SetFilePointer - lseek
GetFileAttributesEx - stat
CreateDirectory - mkdir
RemoveDirectory - rmdir
SetCurrentDirectory - chdir
GetLocalTime - time
Fonte: (SILBERSCHATZ, 2009)
Figura 9- Biblioteca Windows, Unix
Figura 10 Chamadas Windows
Fonte: (TANENBAUM,2016)
Gerenciamento de processos
Os processadores implementam uma instrução especial que permite acionar o mecanismo de interrupção de forma intencional, sem depender de eventos externos ou internos. Ao ser executada, essa instrução (int no Pentium, syscall no MIPS) comuta o processador para o nível privilegiado e procede de forma similar ao tratamento de uma interrupção. Por essa razão, esse mecanismo é denominado interrupção de software. (MEADOR,2018)
A chamada Fork e um bom ponto para se criar um novo processo no POSIX, ele cria uma cópia do processo original incluindo os descritores de arquivos registrados, o processo original e a cópia (Processo pai e filho) seguem caminhos separados , mesmo tendo os processos copiados de forma exata eles não sofrem nenhum tipo de conflito pois a chamada Fork retorna um valor zero , que o zero no processo do filho e igual ao PID (Process Ifdentifier - identificador de processos . Usando o PID ele irá retornar os dois processos e identificar qual é o processo filho ou pai. (TANEBAUM,2016)
Na maioria dos casos após um Fork o processo filho necessita executar um código diferente do processo pai, considere o caso de Shell, ele faz a leitura de um comando do terminal e cria um processo filho, espera ele executar e então lê o próximo comando quando ele terminar. (TANEBAUM,2016)
Até que o processo filho termine, o processo pai executa uma chamada de sistema Waitpid, que espera o processo filho terminar .Waitpid pode esperar por um processo filho especifico ou qualquer outro processo que estiver configurado para ser executado primeiro, quando o Waitpid termina o endereço apontado pelo parâmetro Statloc , será configurado como estado de saída do processo filho .Várias opções são fornecidas pelo terceiro parâmetro, por exemplo, retornar imediatamente se nenhum processo filho já estiver terminado. (TANEBAUM,2016)
Outro registrador ainda é o PSW (Program Status Word — palavra de estado do programa). Esse registrador contém os bits do código de condições, que são estabelecidos por instruções de comparação, a prioridade da CPU, o modo de execução (usuário ou núcleo) e vários outros bits de controle. Programas de usuários normalmente podem ler todo o PSW, mas em geral podem escrever somente parte dos seus campos. O PSW tem um papel importante nas chamadas de sistema e em E/S. (MEADOR,2018)
O POSIX define uma interface minimalista de chamadas de sistema à qual os sistemas UNIX em conformidade devem dar suporte. Na realidade, alguns outros sistemas operacionais também dão suporte hoje em dia à interface POSIX. (MEADOR,2018)
Fonte: (MEADOR, 2018)
Figura 11 - Chamadas POSIX
Diretórios de objeto e ligações simbólicas são locais à parte do espaço de nomes do NT administrados pelo gerenciador de objetos. Eles são similares aos seus correspondentes no sistema de arquivos: os diretórios permitem aos objetos relacionados serem mantidos juntos. Ligações simbólicas permitem a um nome em uma parte do espaço de nomes do objeto referenciar um objeto em uma parte diferente do espaço de nomes do objeto. (MEADOR,2018)
Cada dispositivo conhecido pelo sistema operacional tem um ou mais objetos de dispositivos que contêm informações sobre eles e são usados pelo sistema para referenciar um dispositivo. Por fim, cada driver de dispositivo que tenha sido carregado tem um objeto de driver no espaço de objetos. Os objetos de driver são compartilhados por todos os objetos de dispositivos que representam instâncias dos dispositivos controlados por aqueles drivers como podemos ver na Figura 8. (MEADOR,2018)
Figura 12 - Comando Shell
Fonte: (SILBERSCHATZ, 2009)
.
Figura 13 - Gerenciamento de processos
Fonte: (TANENBAUM, 2016)
 O comando Execve do Linux possui três parâmetros, nome do arquivo a ser executado, um ponteiro para arranja de argumentos e um ponteiro para arranjo de ambiente,várias rotinas de biblioteca incluindo excel, execv, execle, execve, são fornecidas para permitir que os parâmetros sejam omitidos ou especificados de várias maneiras. (TANEBAUM,2016)
Fonte: (FAINA, 2002)
Figura 14 - Comando Execve
 
Fonte: (FAINA, 2002)
Figura 15 - Comando Execl
CP fd1 fd2 São utilizados para copia o fd1 para o fd2.Após o Shell ter criado o processo filho este localiza e executa o arquivo cp e passa para ele os nomes dos arquivos de origem e de destino. (TANEBAUM,2016)
O programa principal de cp , contém a declaração main (arg, argv, envp) onde arg e a contagem de número de itens na linha de comando incluído o nome do programa , o segundo parâmetro arvg e um ponteiro de arranjo o elemento i do arranjo e um ponteiro para a i-ésima cadeia de caracteres na linha de comando . arvg[0] apontaria para a cadeira de caracteres cp , argv[1] apontaria para o fd1 e arvg[2] apontaria para o fd2. (TANEBAUM,2016)
Fonte: (MEADOR,2018)
Figura 16 - Biblioteca padrão
O terceiro parâmetro do main, envp e um ponteiro ara ambiente, um arranjo de cadeia de caracteres que contém atribuições da forma nome = valor usada para transmitir informações do tipo terminal e o nome do diretório home para programas. (TANEBAUM,2016)
Fonte: (FAINA, 2002)
Figura 17 - Comando execve
Gerenciamento de Arquivos 
Muitas chamadas de sistemas relacionam-se ao sistema de arquivos, para ler ou escrever um arquivo é necessário abri-lo, essa chamada é especifica para identificar o arquivo que será aberto. (TANEBAUM,2016)
O descritor de arquivos retornado pode ser usado para leitura ou escrita, em seguida o arquivo pode ser fechado por CLOSE, assim tornando o descritor disponível para ser reutilizado em um open subsequente. (TANEBAUM,2016)
As últimas quatro funções da API listadas são para gerenciamento de arquivos mapeados em memória. Para mapear um arquivo, é preciso primeiro criar um objeto de mapeamento de arquivo (veja a Figura 11.8), com CreateFileMapping. Essa função retorna um descritor para o objeto de mapeamento de arquivos (ou seja, um objeto de seção) e opcionalmente passa um nome para ele dentro do espaço de nomes Win32 e, portanto, outro processo pode usá-lo. As duas funções seguintes mapeiam e desfazem o mapeamento de visões dos objetos de seção a partir do espaço de endereçamento virtual de um processo. A última função da API pode ser usada por um processo para compartilhar um mapeamento criado por outro processo com CreateFileMapping e normalmente criado para mapear memória anônima. Dessa maneira, dois ou mais processos podem compartilhar regiões de seus espaços de endereçamento. Essa técnica permite-lhes escrever em regiões confinadas da memória virtual um do outro. (TANEMBAUM 2016)
Figura 18 - Gerenciamento de arquivo
Fonte: (TANEMBAUM 2016)
As chamadas mais utilizadas são as READ e Write, write tem os mesmos parâmetros do READ. Embora a maioria dos programas leia e escreva arquivos sequencialmente, alguns programas precisam ser capazes de acessar qualquer parte de arquivos de modo aleatória chamada Lseek muda o valor do ponteiro de posição, de maneira que chamadas subsequentes para ler ou escrever podem começar em qualquer parte no arquivo. (TANEBAUM,2016)
Lseek tem três parâmetros o primeiro e descritor de arquivos, o segundo e a localização do arquivo e a terceira diz se a posição do arquivo é relativa ao começo (TANEBAUM,2016)
Gerenciamento de Diretórios
Chamadas de gerenciamento de diretórios se relaciona com mais diretórios ou sistema de arquivos como um todo, em vez de apenas um arquivo especifico como as chamadas anteriores, as primeiras chamadas, MDKDIR e RMDIR criam e removem diretórios vazios. Sua finalidade é permitir que o mesmo arquivo apareça sob dois ou mais nomes , muitas vezes em diretórios diferentes , um uso típico e permitir vários membros da mesmo equipe de programação compartilhem arquivos em comum , compartilhar um arquivo não e o mesmo que dar a cada membro da equipe uma cópia do arquivos mas sim um arquivo que e compartilhado em vários usuários , caso um usuário alterar esse arquivo será visível para todos os outros da equipe esse tipo de alteração. (TANEBAUM,2016)
Para entendermos como um link funciona, temos dois usuários Ast e Jim cada um com o seu próprio diretório com alguns arquivos. (TANEBAUM,2016)
link (“/usr/jim/memo”, “/usr/ast/note”); 
O arquivo de memo. de jim como podemos ver na Figura 4 estará aparecendo no diretório de ast sobe o nome note, daí em diante /usr/jim/memo e /usr/ast/note referem-se ao mesmo arquivo. Como uma nota, se os diretórios serão mantidos em /usr, /user, /home, ou em outro lugar é apenas uma decisão tomada pelo administrador do sistema local. (TANEBAUM,2016)
TANEBAUM,2016
Figura 19 - Arquivo de memo
Como mencionamos antes, a chamada de sistema mount permite que dois sistemas de arquivos sejam fundidos em um. Uma situação comum é ter o sistema de arquivos-raiz, contendo as versões (executáveis) binárias dos comandos comuns e outros arquivos intensamente usados, em uma (sub)partição de disco rígido e os arquivos do usuário em outra (sub)partição. Posteriormente o usuário pode ainda inserir um disco USB com arquivos para serem lidos. Ao executar a chamada de sistema mount, o sistema de arquivos USB pode ser anexado ao sistema de arquivos-raiz, como mostrado na Figura 1.22. Um comando típico em C para realizar essa montagem é mount(“/dev/sdb0”, “/mnt”, 0); onde o primeiro parâmetro é o nome de um arquivo especial de blocos para a unidade de disco 0, o segundo é o lugar na árvore onde ele deve ser montado, e o terceiro diz se o sistema de arquivos deve ser montado como leitura e escrita ou somente leitura. (MEADOR,2018)
Após a chamada mount, um arquivo na unidade de disco 0 pode ser acessado usando o seu caminho do diretório-raiz ou do diretório de trabalho, sem levar em consideração em qual unidade de disco ele está. Na realidade, a segunda, terceira e quarta unidades de disco também podem ser montadas em qualquer parte na árvore. A chamada mount torna possível integrar meios removíveis em uma única hierarquia de arquivos integrada, sem precisar preocupar-se em qual dispositivo se encontra um arquivo. Embora esse exemplo envolva CD-ROMs, porções de discos rígidos (muitas vezes chamadas partições ou dispositivos secundários) também podem ser montadas dessa maneira, assim como discos rígidos externos e pen drives USB. Quando um sistema de arquivos não é mais necessário, ele pode ser desmontado com a chamada de sistema umount. (MEADOR,2018)
Fonte: (TANENBAUM,2019)
Figura 20 Sistema de arquivos
Sinalização
As chamadas mais importantes relacionadas com as variáveis de condição são mostradas na Figura 23. Como você provavelmente esperaria, há chamadas para criar e destruir as variáveis de condição. Elas podem ter atributos e há várias chamadas para gerenciá-las (não mostradas). As operações principais das variáveis de condição são pthread_cond_wait e pthread_cond_signal. O primeiro bloqueia o thread que chamou até que algum outro thread sinalize (usando a última chamada). As razões para bloquear e esperar não são parte do protocolo de espera e sinalização, é claro. O thread que é bloqueado muitas vezes está esperando pelo que sinaliza para realizar algum trabalho, liberar algum recurso ou desempenhar alguma outra atividade. Apenas então o thread que bloqueia continua. As variáveis de condição permitem que essa espera e bloqueio sejam feitos atomicamente. A chamada pthread_cond_broadcast é usada quando há múltiplos threads todos potencialmente bloqueados e esperando pelo mesmo sinal. (TANEBAUM,2016)
Fonte: (TANEMBAUM,2016)
Figura 21 - Sinalização
Variáveis de condição e mutexes são sempre usados juntos. O padrão é um thread travar um mutex e, então, esperar em uma variável condicional quando ele não consegue o que precisa. Por fim, outro thread vai sinalizá-lo, e ele pode continuar. A chamada pthread_ cond_wait destrava atomicamente o mutex que o está segurando. Por essa razão, o mutex é um dos parâmetros. (TANEBAUM,2016)
As sinalizações (flags)Fig.24 são bits ou campos curtos que controlam ou habilitam alguma propriedade específica. Arquivos ocultos, por exemplo, não aparecem nas listagens de todos os arquivos. A sinalização de arquivamento é um bit que controla se foi feito um backup do arquivo recentemente. O programa de backup remove esse bit e o sistema operacional o recoloca sempre que um arquivo for modificado. Dessa maneira, o programa consegue dizer quais arquivos precisam de backup. A sinalização temporária permite que um arquivo seja marcado para ser deletado automaticamente quando o processo que o criou for concluído. (TANEBAUM,2016)
Fonte: (TANEMBAUM,2016)
Figura 22 - Biblioteca Sinalização
Proteção
Nos dias de hoje a internet vem tornando mais pratica o dia a dia das pessoas devido ao grande número de serviços disponíveis. Grande parte deles envolvem operações financeiras como por exemplo compra e venda de produtos e internet banking. Essa praticidade, no entanto, atrai um tipo indesejado de software, os malware. Normalmente este tipo de programa realiza ações na máquina do usuário sem o seu consentimento podendo roubar e destruir dados importantes [1]. De acordo com pesquisas recentes, o n´úmero de malware observados no período entre janeiro a setembro de 2010 foi de aproximadamente 14 milhões, um valor superior em um milhão ao mesmo período do ano passado. [2]. Isto torna indispensável o uso de medidas de combate a este tipo de problema. Uma delas é o uso de antivírus, software que ficam monitorando a máquina constantemente em busca de arquivos infectados ou com comportamento suspeito. Para identificar estes arquivos é necessário primeiro ter um exemplo de comportamento malicioso, que pode ser obtido através da análise dinâmica de artefatos maliciosos. Com ela é possível verificar quais ações foram realizadas pelo programa durante a sua execução. (MEADOR,2018)
O resultado gerado por essa análise possibilita que seja obtido o comportamento malicioso do malware. O trabalho proposto visa criar um sistema de análise de artefatos maliciosos (BEHEMOT) que consiga obter informações sobre a execução do artefato e o tráfego de rede gerado durante a análise. Esse sistema deve ser capaz de analisar arquivos do tipo PE 32 e executar executáveis de sistemas Windows. Como grande parte dos computadores usam Windows a maioria dos malware são desenvolvidos para este sistema operacional. Além disso, ele não deve ser dependente de arquitetura como alguns sistemas que só executam em ambiente emulado como por exemplo o Anúbis, um sistema de análise dinâmica muito conhecido e utilizado que utiliza uma versão modificada do Qemu para realizar a análise do malware. (MEADOR,2018)
 Essa característica é importante pois o sistema deve ser utilizar arquitetura emulada e real, tornando possível a análise de artefatos que não podem ser executados em ambiente emulado. Outra característica desejada é com relação aos resultados das análises. Eles devem apresentar somente as ações maliciosas efetuadas pelo binário, excluindo o máximo possível qualquer ruído proveniente de ações do sistema operacional. Os resultados preliminares do BEHEMOT mostram que ele consegue analisar mais malware que outras ferramentas, devido sua arquitetura híbrida que utiliza máquinas reais e emuladas na análise. Outro ponto relevante foram as análises que se mostraram mais objetivas, com poucas ações provenientes do sistema operacional apresentando em sua maioria somente o comportamento malicioso. (TANEMBAUM 2016)
Tokens de acesso são objetos de segurança; eles identificam um usuário e dizem quais privilégios especiais o usuário possui (se os possuir). Perfis são estruturas usadas para armazenar amostras periódicas do contador de programas de um thread em execução, para saber onde o programa está gastando seu tempo. (MEADOR,2018)
Como podemos ver na Figura 25 os primeiros quatro atributos que são proteção, senha, criador, proprietário concernem à proteção do arquivo e dizem quem pode acessá-lo e quem não pode. Todos os tipos de esquemas são possíveis. Em alguns sistemas o usuário deve apresentar uma senha para acessar um arquivo, caso em que a senha deve ser um dos atributos. (TANEBAUM,2016)
. Set attributes. Alguns dos atributos podem ser alterados pelo usuário e modificados após o arquivo ter sido criado. Essa chamada de sistema torna isso possível. A informação sobre o modo de proteção é um exemplo óbvio. A maioria das sinalizações também cai nessa categoria. (TANEBAUM,2016)
Fonte: TANEMBUAM 2016
Figura 23 – Atributos
Gerenciamento de Tempo
O POSIX define uma série de rotinas para lidar com o tempo. Por exemplo, time retorna o tempo atual somente em segundos, com 0 correspondendo a 1o de janeiro, 1970, à meia-noite (bem como se o dia estivesse começando não terminando). Em computadores usando palavras de 32 bits, o valor máximo que time pode retornar é 232 −1. Esse valor corresponde a um pouco mais de 136 anos. Desse modo, no ano 2106, sistemas UNIX de 32 bits entrarão em pane. (TANEBAUM,2016) 
Fonte: (CRESTANA, 2011)
Figura 24 - Gerenciamento de tempo
 Ao desacoplar a interface API das chamadas de sistema reais, a Microsoft retém a capacidade de mudar as chamadas de sistema reais a qualquer tempo sem invalidar os programas existentes. O que de fato constitui o Win32 também é um tanto ambíguo, pois versões recentes do Windows têm muitas chamadas novas que não estavam disponíveis anteriormente. Nesta seção, Win32 significa a interface que conta com o suporte de todas as versões do Windows. A Win32 proporciona compatibilidade entre as versões do Windows. (TANEBAUM,2016)
Figura 25 - Chamada de interface
 (TANEMBAUM 2016)
Os vários registros de tempo controlam quando o arquivo foi criado, acessado e modificado pela última vez, os quais são úteis para uma série de finalidades. Por exemplo, um arquivo-fonte que foi modificado após a criação do arquivo-objeto correspondente precisa ser recompilado. Esses campos fornecem as informações necessárias. (TANEBAUM,2016)
Fonte: (TANEMBAUM 2016)
Figura 26 - Registro de tempo
CONCLUSÃO
 
Chamadas De Sistemas são funções específicas que invocam o sistema operacional para que este faça algo, como a criação de um processo. Como as rotinas do sistema possuem em seu código instruções privilegiadas. As Chamadas De Sistemas são como portas de entrada para se ter acesso as rotinas do SO. Se uma aplicação desejar chamar uma rotina do sistema operacional: mecanismo de system call verificará se a aplicação possui os privilégios necessários. Caso tente executar uma instrução privilegiada (rotinas do sistema) sem ser por intermédio de um system call, um mecanismo de proteção por hardware impedirá a operação. As sinalizações (flags) são bits ou campos curtos que controlam ou habilitam alguma propriedade específica. Arquivos ocultos, por exemplo, não aparecem nas listagens de todos os arquivos. A sinalização de arquivamento é um bit que controla se foi feito um backup do arquivo recentemente.
REFERÊNCIAS
TANEMBAUM. Andrew Tanenbaum. Sistemas Operacionais Modernos. 2016. Disponível em: https://www.souexatas.com/2018/10/sistemas-operacionais-modernos.html
Acesso em: 25 agosto. 2019.
CRESTANA. Hélio Crestana Guardia .Chamadas de sistemas.2011. Disponível em: 
http://livresaber.sead.ufscar.br:8080/jspui/bitstream/123456789/2458/1/SO_-_AT0_Chamadas_de_Sistema.pdf
Acesso em 27 outubro.2019.
MEADOR. David Meador . Chamadas do sistema em Unix e Windows .2018. Disponível em:
https://www.tutorialspoint.com/system-calls-in-unix-and-windows
Acesso em 10 de novembro 2019.
FAINA. Luíz.F.Faina. Introdução aos Sistemas Operacionais.2002. Disponível em:
http://www.dca.fee.unicamp.br/~eleri/ea876/02/so-apst.pdf
Acesso em 10 de novembro 2019.