Instituto de Computação - UNICAMP

MC504/MC514 - Sistemas Operacionais

Implementação de Chamadas de Sistema

Islene Calciolari Garcia

Ambiente de testes

QEMU

O QEMU é um virtualizador e emulador de processadores. Podemos fazer um teste bem simples com o QEMU utilizando a imagem disponível em Testing QEMU .

  qemu-system-x86_64 -hda linux-0.2.img

Teste com o kernel 3.12

Atenção: como estes arquivos são muito grandes, deveremos fazer nossos testes no /tmp das máquinas do laboratório.

Precisaremos do arquivo mc504-linux.tar.xz. Se estivermos na rede do IC-03 podemos executar o seguinte comando:
```
$  cp /home/staff/islene/public_html/mc504-linux.tar.xz .
```
Após obtermos o arquivo, devemos executar:
```
$ tar xJvf mc504-linux.tar.xz
```
Surgirá um diretório contendo a versão 3.12 do kernel Linux compilada com o arquivo de configuração config-3.12 e uma imagem mc504.img que foi criada por Glauber de Oliveira Costa para a turma do 1s2008 de sistemas operacionais.

Teste o kernel com a imagem utilizando o QEMU:

  qemu-system-x86_64 -hda mc504.img -kernel linux-3.12/arch/i386/boot/bzImage -append "ro root=/dev/hda"

Quando o sistema entrar poderemos fazer login com
```
    usuário: root
    senha:   root
  
```

Primeira chamada

Antes de fazermos uma chamada de sistema mais elaborada, vamos testar uma que não recebe parâmetros e retorna uma constante. Chamaremos esta chamada de mycall.

Alterar a tabela linux-3.12/arch/x86/syscalls/syscall_32.tlb, acrescentando uma nova linha ao final do arquivo, após a linha do finit_module
```
  350     i386    finit_module            sys_finit_module
  351     i386    mycall                  sys_mycall
```
Incluir uma declaração da função sys_mycall em linux-3.12/include/linux/syscalls.h, novamente após a linha relacionada ao finit_module
```
asmlinkage long sys_finit_module(int fd, const char _user *uargs, int flags);
asmlinkage long sys_mycall(void);
```
Incluir o código para função no diretório linux-3.12/arch/x86/kernel/. Podemos utilizar o arquivo mycall.c, cujo conteúdo é:
```
#include <linux/unistd.h>
#include <linux/linkage.h>

asmlinkage long sys_mycall() {
  return(4096);
}
```
Alterar o Makefile do diretório linux-3.12/arch/x86/kernel/, incluindo uma linha:
```
obj-y                                   += mycall.o
```
No diretório linux-3.12 executar
```
  $ make 
  
```
Para não ter problemas com a quota, configure o diretório CCACHE utilizando o comando:
```
$ export CCACHE_DIR="/tmp/.ccache"export CCACHE_DIR="/tmp/.ccache"
```

Escrever um programa para testar a chamada em modo usuário. Pode ser um programa bem simples como ex-mycall.c:

/* 
 * Teste da nova chamada de sistema
 */ 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
  int r = syscall(351); 
  printf("Retorno da chamada de sistema: %d.\n", r);
  return r;
}

Compilar o programa, considerando que a imagem foi feita para i386. As opções são:
- Compilar normalmente em uma máquina i386 (não é o caso das máquinas do laboratório).
- Utilizar o gcc cross compiler (não está configurado nas máquinas do laboratório).
- Utilizar o compilador http://www.onlinecompiler.net/ccplusplus. Note que não é seguro rodar um código gerado em um site como esses. No entanto, como utilizaremos este código apenas no ambiente virtualizado, não há problema (ou, pelo menos, o risco é bem menor).

Rodar o programa no QEMU:

Devemos iniciar o sistema com o comando:

  qemu-system-x86_64 -hda mc504.img -kernel linux-3.12/arch/i386/boot/bzImage -append "ro root=/dev/hda" -hdb ex-mycall

Após logar no sistema, devemos executar:

$ cat /dev/hdb > ex-mycall
$ chmod +x ex-mycall
$ ./ex-mycall

Projeto

Você deverá implementar uma chamada de sistema que receba pelo menos um parâmetro e que trabalhe com pelo menos um elemento do sistema operacional (processos, memória, dispositivos, ...). A ideia é que você adicione uma pequena funcionalidade ao kernel; nã precisa ser algo útil na prática. Você deverá implementar também um pequeno teste, como o ex-mycall.

Entrega

Como feito para o projeto 1, cada grupo deverá fazer uma pequena apresentação e deixar o seguinte conteúdo disponível:

Arquivo README contendo a descrição da chamada e como os outros arquivos devem ser instalados/testados.
Arquivo com código da chamada de sistema.
Arquivo teste.

Data de entrega: 27 de novembro.

Data de entrega com atraso: 3 de dezembro, valendo 80% da nota.

Submissão de patches

As submissões de patches seguem um padrão bem diferente. Com o auxílio da ferramenta git é gerado um arquivo contendo apenas as diferenças entre o código a ser submetido e uma dada versão do kernel. Para saber mais sobre isso, veja, por exemplo o vídeo Write and Submit your first Linux kernel Patch.