CI064 – Software Básico – Turma 2010-1

Nome: Pedro Henrique Xavier Rossetti GRR: 20075573

Este texto descreve chamadas de sistemas (syscalls) modelos POSIX e Data: 25/06/2010
Win32, e um tutorial de como incluir uma chamada de sistema no linux.

System calls

Uma system call, ou chamada de sistema, é a maneira que um programa em execução tem de
se comunicar com o sistema operacional, e, através desta comunicação, pedir recursos externos do
programa, como abertura de arquivos, gerenciamento de memória e etc.
O sistema operacional faz a intermediação entre o programa em execução e os recursos do
computador, isso ocorre, principalmente, por motivo de segurança, pois um programa não pode ter
acesso a todo o sistema.
Quando ocorre uma chamada de sistema, o programa que a chamou é interrompido, e a
informação necessária para continuar a sua execução é salva. O processador inicia a execução do
código de maior prioridade que, examinando o estado do processador (definido pelo código de
menor prioridade) e/ou a sua pilha, determina que serviço foi requisitado. Quando a chamada
termina, o controle retorna para o programa, o estado previamente salvo é restaurado, e o programa
continua a sua execução.
Cada sistema operacional possui seu próprio conjunto de rotinas, com nomes, parâmetros e
formas de ativação específicos, e é por esse motiva que uma aplicação compilada em um sistema X,
não pode ser executada diretamente em um sistema operacional Y.

System calls no Linux (POSIX)

O termo PosIX (Portable Operating System Interface for Unix) foi elaborado pelos institutos
ISO e IEEE. Inicialmente voltado para a unificação das várias versões do SO Unix, o POSIX
estabeleceu uma biblioteca padrão, permitindo que uma aplicação desenvolvida seguindo este
conjunto de chamadas possa ser portada para os demais sistemas. A maioria dos sistemas
operacionais modernos oferece algum suporte ao padrão POSIX
Cada chamada do sistema é diversificada no kernel através de um único ponto de entrada. O
registro eax é utilizado para identificar a chamada do sistema específica que deve ser chamada, que
é especificada na biblioteca C (pela chamada a partir do aplicativo de espaço do usuário). Quando a
biblioteca C tiver carregado o índice da chamada do sistema e qualquer argumento, uma interrupção
de software é invocada (interrupção 0x80), que resulta na execução (através do manipulador de
interrupção) da syscall. Essa função manipula todas as chamadas do sistema, conforme identificado
pelo conteúdo do registrador eax. A chamada do sistema é invocada utilizando a tabela de chamadas
de sistema junto com o índice contido no registrador eax. No retorno da chamada do sistema,
syscall_exit é finalmente atingida e uma chamada para transições resume_userspace de volta ao
espaço do usuário. A execução continua na biblioteca C que, em seguida, retorna para o aplicativo
de usuário.

System calls no Windows (Win32)

O Windows define uma API (Application Programming Interface) de chamada Win32,

contendo todas as system calls do sistema operacional.
Para criar um processo com a Win32 API existe uma função chamada CreateProcess, esta
função possui nada mais nada menos do que10 parâmetros, onde são configurados o programa que
será carregado, prioridade do processo, atributos de segurança, etc.
Para a comunicação entre as diferentes aplicações Windows, a Microsoft desenvolveu uma
série de tecnologias junto a API principal. Isso começou com Dynamic Data Exchange (DDE), que
foi substituído pelo Object Linking and Embedding (OLE) e, posteriormente, pelo Component
Object Model (COM), objetos de automação, controles ActiveX e. NET Framework.
Por que o Linux é mais seguro do que o Windows? A resposta dessa pergunta está
justamente nas chamadas de sistema. A Microsoft, por uma questão de compatibilidade com
softwares mais antigos, é obrigada a deixar algumas chamadas de sistemas que executam de
maineira ilegal em seu sistema operacional, tornando-o vulnerável.

Wine e ReactOS

Wine (WINE Is Not an Emulator, isto é, WINE Não é um Emulador) é um aplicativo que
roda em ambiente unix e permite executar nesse ambiente um software especificamente concebido
para o Microsoft Windows.
O WINE é uma implementação livre das chamadas de sistema do Windows no Linux, não
sendo portanto um emulador, pois ele não faz nenhuma emulação para executar softwares para
Windows. O WINE funciona como uma camada que expõe uma API compatível com a do
Windows. Ao serem executadas as diferentes funções, o Wine irá traduzi-las para rotinas em UNIX
cujo resultado seja idêntico.
ReactOS é um sistema operacional em software livre, licenciado sob a GNU GLP, cujo
objetivo é desenvolver um sistema operacional 100% compatível com os aplicativos e drivers
binários para Windows, sendo distribuido totalmente de graça. O ReactOS vai um passo além do
Wine e visa proporcionar uma aplicação de todo o sistema operacional Windows.

Inserindo um syscall em ambiente Unix

A principio não temos motivos para fazer novas chamadas de sistema, parece que tudo o que
precisamos já está implementado, no entanto, quando precisamos de velocidade, implementar novas
system calls é uma boa ideia.
Abaixo segue um tutorial de como incluir uma nova chamada de sistema em um ambiente
unix.

Adicionando uma syscall a um kernel

1. O primeiro passo é fazer download do kernel em que você deseja incluir sua nova
system call.

2. Descompacte o kernel em sua máquina no local /usr/src, geralmente ele vem em formato
tar.gz ou tar.bz2, após a descompactação será criado um diretório com o kernel,
geralmente chamado de linux-X.X.X, onde os X's representam a versão baixada do
kernel.

3. Dentro do diretório linux-X.X.X crie um diretório com o nomde sua preferência, no meu
caso, o criei com o nome de chamada_sistema.

4. Dentro do diretório chamada_sistema crie dois arquivos, um com o nome da sua função
em .c, no meu caso o chamarei de chamada_sistema.c, e um arquivo chamada Makefile.

5. No arquivo .c criado, você implementará sua system call, para esta disciplina, foi pedido
uma chamada que retorne o número de vezes que a system call foi chamada até o
momento por meio de uma impressão em log, no caso, utilizando o printk().
 int syscall(void)
{
static int contador = 0;
printk("Syscall chamada %d-ésima\n", contador++);
return(1);
}

6. O arquivo Makefile possuirá as instruções para compilação da syscall, para o exemplo

de cima, será:

obj-y := chamada_sistema.o

7. Agora temos que incluir nossa syscall na tabela de chamadas de sistema que esta no
arquivo chamado syscall_table_32.S, seu caminho será /usr/src/linux-
X.X.X/arch/x86/kernel, adicionamos, na ultima linha, neste exemplo, .long
sys_chamada_sistema.

8. Incluiremos agora, nossa syscall no arquivo unistd_32.h , que está no seguinte

caminho: /usr/src/linux-X.X.X/arch/x86/include/asm. Adicionaremos uma nova linha
depois da ultima syscall definida, neste exemplo é a 337, teremos agora, então, uma 338,
chamada da seguinte forma: “__NR_chamada_sistema 338”.

9. Precisamos adicionar nosso Makefile criado em /usr/scr/linux-X.X.X/chamada_sistema,

no Makefile principal (localizado em /usr/scr/linux-X.X.X), para isso, na linha que
contém um core-y, adicionaremos o caminho do nosso Makefile, que no neste caso é
chamada_sistema/.

Compilando o kernel com a nova syscall

1. Entre na pasta /usr/src/linux-X.X.X e copie sua configuração atual usando cp /boot/config-

versão_atual /usr/src/linux-X.X.X/.config.

2. Dentro de /usr/src/linux-X.X.X execute o comando make menuconfig e escolha a opção

“Load an Alternate Configuration File”, escolha “.config”, confirme, selecione exit,
confirme novamente e quando aparecer a mensagem “Do you wish to save your new kernel
configuration?”, selecione yes e confirme mais uma vez.

3. Execute em /usr/src/linux-2.6.11.11 o comando make&&make modules_install. Este

comando faz três coisas: o make faz a compilação do kernel, a compilação dos modulos é
feita por make modules e a compilação da imagem de inicialização pelo make BzImage, no
caso, o BzImage foi omitido. Lembrando que podemos executa-los separadamente.

4. Agora é precisamos fazer a cópia de dois arquivos que serão necessários para a
inicialização do sistema, utilizaremos os comandos: cp /usr/src/linux-
X.X.X/arch/i386/boot/bzImage /boot/vmlinuz-X.X.X e cp /usr/src/linux-X.X.X/System.map
/boot/System.map-X.X.X.
 5. Crie o arquivo initrd-X.X.X.img que irá carregar os modulos do seu kernel durante a
inicialização com o comando: mkinitramfs -o /boot/initrd.img-X.X.X /lib/modules/X.X.X.

6. Pronto, o kernel com a nova system call já está compilado e instalado, agora basta
configurar seu gerenciador de boot, para isso, faça ele apontar para /vmlinuz-X.X.X.

Fontes: http//:www.wikipedia.org, http//:www.ibm.com, material disponibilizado pelo professor

Bruno Muller em http//:www.inf.ufpr.br/bmuller.