Trabalho de Sistemas Operacionais Prof. Fernando Luís Dotti IMPLEMENTAÇÃO DE UMA NOVA CHAMADA DE SISTEMA NO LINUX

Transcrição

1 Trabalho de Sistemas Operacionais Prof. Fernando Luís Dotti IMPLEMENTAÇÃO DE UMA NOVA CHAMADA DE SISTEMA NO LINUX

2 Alunos: Andrio Spich Hugo A. W. Schmitt

3 Introdução A proposta deste trabalho de sistemas operacionais foi trabalhar com um sistema operacional real, no caso, o Linux. A idéia foi de aprender sobre o funcionamento interno do Linux, para que depois pudéssemos alterar o seu código fonte de modo a adicionar uma chamada de sistema simples e colocá-la em funcionamento. As chamadas de sistema são o modo padrão para que um programa de usuário possa utilizar os serviços do Sistema Operacional. Ambiente para o trabalho Nos laboratórios de rede possuímos acesso em modo de superusuário ao Linux, no caso a distribuição Kurumin. Infelizmente estes não possuíam o código fonte do sistema, necessário para a recompilação do mesmo, e o laboratório de rede não possui acesso à Internet para que pudéssemos realizar o download do mesmo. A solução encontrada foi trabalharmos em casa. Utilizamos a distribuição Red Hat 9, com versão do kernel , arquitetura i386 (PC). Recompilando o kernel Antes mesmo de implementarmos a chamada, preferimos recompilar o kernel sem nenhuma modificação para nos assegurarmos de que quaisquer problemas que apareçam durante ao trabalho sejam relacionados realmente ao trabalho. O kernel do linux (quando estiver instalado) se encontra no diretório /usr/src. Utilizando a ferramenta de montagem make, efetuamos a compilação do kernel nas seguintes etapas:

4 make clean para remover quaisquer arquivos.o antigos. make config para configurar as opções para o nosso kernel.(poderíamos executar make menuconfig e realizar a configuração toda (ou xconfig para um modo gráfico), mas como já possuímos um arquivo de configuração que funcionava, utilizamos oldconfig para que se realize a configuração a partir do arquivo.config. make dep para verificar as dependências corretamente. Aqui começa a compilação propriamente dita: make bzimage Temos agora a imagem do kernel nova bzimage no diretório./arch/i386/boot/ Para acabarmos a instalação devemos compilar os módulos e instalá-los: make modules make modules_install Por segurança, iremos deixar duas versões do kernel no sistema, a antiga e a nova, uma vez que uma compilação bem sucedida não significa que o kernel irá realmente funcionar. Copiamos a imagem do kernel da pasta local para /boot/ (devemos estar em modo superusuário) cp./arch/i386/boot/bzimage /boot Neste caso, a nova imagem se chama bzimage

5 No gerenciador de boot criaremos uma nova entrada correspondente ao kernel recompilado; se utilizamos o Grub devemos alterar o arquivo /boot/grub/menu.lst de modo que teremos algo como: #boot=/dev/hda default=2 timeout=10 splashimage=(hd0,1)/grub/splash.xpm.gz title Linux ( ) root (hd0,1) kernel /vmlinuz ro root=label=/ hdc=ide-scsi initrd /initrd img title Testing linux (new system call) root(hd0,1) kernel /bzimage ro root=/dev/hda3 Basta reiniciar agora o computador: reboot Preparando para uma nova chamada de sistema

6 As chamadas de sistema são chamadas indiretamente via interrupções. Temos uma tabela de interrupções que será acessada pelos processos de usuário para que encontrem a interrupção desejada. Temos que inserir uma nova entrada nesta tabela que se encontra no arquivo linux/arch/i386/kernel/entry.s. O nosso arquivo ficou assim:.long SYMBOL_NAME(sys_ni_syscall) /* 250 sys_alloc_hugepages */.long SYMBOL_NAME(sys_ni_syscall) /* sys_free_hugepages */.long SYMBOL_NAME(sys_exit_group).long SYMBOL_NAME(sys_lookup_dcookie).long SYMBOL_NAME(sys_userproc) /* Nossa syscall */.long SYMBOL_NAME(sys_ni_syscall) /* 255 sys_epoll_ctl */.long SYMBOL_NAME(sys_ni_syscall) /* sys_epoll_wait */.long SYMBOL_NAME(sys_ni_syscall) /* sys_remap_file_pages */ Normalmente se insere uma nova chamada de sistema na última posição, mas nós inserimos perto do fim, pois ali haviam algumas posições inutilizadas. Também temos que alterar o arquivo linux/include/asm-i386/unistd.h: #define NR_io_submit 248 #define NR_io_cancel 249 #define NR_alloc_hugepages 250 #define NR_free_hugepages 251 #define NR_exit_group 252 #define NR_lookup_dcookie 253 #define NR_userproc 254 #define NR_set_tid_address 258 Inserindo a nova chamada de sistema

7 Há várias maneiras de criarmos a chamada de sistema; nós optamos pelo modo mais simples e utilizamos apenas um arquivo userproc.c que colocamos, arbitrariamente, na pasta kernel. Devemos então modificar a Makefile desta pasta para que o código seja compilado e linkado corretamente. A modificação está em negrito: #Começo do arquivo O_TARGET := kernel.o export-objs = signal.o sys.o kmod.o context.o ksyms.o pm.o exec_domain.o printk.o cpufreq.o profile.o obj-y = sched.o dma.o fork.o exec_domain.o panic.o printk.o lowlat.o profile.o module.o exit.o itimer.o info.o time.o softirq.o resource.o sysctl.o acct.o capability.o ptrace.o timer.o user.o signal.o sys.o kmod.o context.o kksymoops.o futex.o pid.o userproc.o (...) O formato de uma chamada de sistema é o seguinte ( userproc.c ): #include <linux/unistd.h> #include <linux/linkage.h> #include <linux/errno.h> #include <linux/sched.h> #include <linux/kernel.h> asmlinkage int sys_userproc(int user_uid) { struct task_struct *pts; (1) //for_each_process(pts) for (pts = &init_task ; (pts = next_task(pts))!= &init_task; ) (2) { if ( pts-> uid == user_uid){ printk("user %d eh dono do processo %d\n",pts->uid,pts->pid); (3) return 0; A biblioteca linkage.h é necessário para que o compilador reconheça a palavra asmlinkage. Esta por sua vez é necessária para que as chamadas de sistema sejam linkadas corretamente. Também deve-se colocar sys_ na frente do header da função. Esta nossa chamada de sistema simplesmente lista os processos de um usuário:

8 - recebe como argumento um inteiro user_id, um ID de usuário( Por exemplo, o root tem UID = 0); - para cada processo existente, se o UID relacionado ao processo for igual a user_id, escreve na tela uma mensagem; Em (1), declara-se um ponteiro do tipo task_struct que iremos utilizar para acessarmos as estruturas que mantém os processos; Em (2), temos um for. Observa-se que o endereço init_task nos dá tanto o valor inicial como o limite final do loop. Isto acontece pois todas as tasks do sistema estão relacionadas em uma lista circular duplamente encadeada. Logo o limite final em init_task nós impede de começarmos uma segunda volta e passarmos mais uma vez por todos os processos.(pts = next_task(pts) seta o ponteiro pts para a próxima posição da lista encadeada) Em (3): se o UID do processo é o mesmo da entrada, escrevemos, usando printk, uma mensagem para o console. Testando a chamada de sistema Mostramos ainda um exemplo de como usar a chamada de sistema, pois do jeito que a implementamos o código fonte necessita de uma adição ( testeuserproc.c ): #include <linux/unistd.h> #include <errno.h> //syscalls podem retornar 'error codes' #include <stdio.h> #include <stdlib.h> //atoi

9 _syscall1(long, userproc, int, user_uid); main(int argc, char ** argv) { if (argc!= 2) { printf("lista os processos de alguem\n"); printf("sintaxe: %s uid\n", argv[0]); exit(1); my_syscall(atoi(argv[1])); A única linha interessante aqui é: _syscall1(long, userproc, int, user_uid); Necessitamos desta macro para que um programa de usuário possa usar a chamada de sistema. Nota-se que o número 1 em _syscall1 se refere ao número de argumentos que a função recebe, e há uma limitação máxima de 6 elementos. Esta macro na verdade gera um código assembler que chama a interrupção 80h com a chamada de sistema requerida e seus parâmetros nos registradores. Conclusão Neste trabalho pudemos trabalhar na prática com um sistema operacional moderno e popular. O Linux nunca foi um sistema operacional com fins educativos e no seu código as várias partes em programação assembly mostram que o objetivo é sempre o maior desempenho e não clareza ou elegância. Também notamos que a teoria dos livros sobre Linux de alguns anos atrás só vale para os princípios, pois a implementação já está muito alterada e só se consegue aprender na prática, com base nos comentários nos próprios fontes.