3 Introdução às chamadas ao sistema

Transcrição

1 3 Introdução às chamadas ao sistema 3.1 Chamadas ao sistema e à BIOS As chamadas ao sistema ou System Calls consistem nos serviços disponibilizados pelo núcleo do sistema operativo. O principio é semelhante para chamadas à BIOS, ou interrupções da BIOS, e consiste em colocar argumentos necessários à execução da chamada em registos apropriados do CPU e chamar um interrupção para que o núcleo a execute. De certo modo assemelha-se a uma chamada a uma função, mas a tecnologia envolvida é diferente. Assumindo que se dispõe de um sistema baseado num CPU da família x86 ou compatível, como exemplo de uma função da BIOS, pode-se apresentar a escrita de um caracter na consola na posição corrente do cursor em modo de texto. A interrupção da BIOS usada para os serviços de video é a 10H. No registo AH é colocado o número da função, neste caso será a função 9 escrita de caracter e atributo. Os argumentos são: Registo AL BH BL CX Descrição do argumento código ASCII do caracter Nº da página de video (a memória de video é dividida em páginas correspondentes a um ecran. Só uma é no entanto apresentada) Atributo do caracter (basicamente a côr) Nº de vezes que repete o caracter Assim um programa em assembler que efectue esta operação seria: movb $65, %al ; código ASCII de A movb atr, %bh ; atr contém as cores do caracter (fore and background) movb $0, %bl ; página de video 0 movw $1, %cx ; imprime uma só vez movb $9, %ah ; função que escreve o caracter na posição corrente do cursor int $10h ; serviços da BIOS para video Neste caso não foram devolvidos valores. Mas se se pretender o inverso, isto é lêr o caracter e atributo na posição corrente do cursor, função 8 da interrupção 10H, ter-se-ía como argumentos apenas a página de video: Registo BH Descrição do argumento Nº da página de video e após execução da interrupção seriam devolvidos: Registo AL BL Descrição do argumento código ASCII do caracter Atributo do caracter O programa em assembler que efectua esta operação é: movb $0, %bl ; página de video 0 movb $8, %ah ; função que escreve o caracter na posição corrente do cursor int $10h ; serviços da BIOS para video PIN T03-1/6

2 Deve ser referido que sistemas operativos de 32 bits não usam a BIOS pois normalmente esta consiste num conjunto de rotinas de 16 bits. Para executar os programas acima num sistema operativo de 32 bits, como por exemplo o Linux, ter-se-ía de usar o modo virtual 8086 ou vm Chamadas ao sistema Linux As chamadas ao sistema operativo, Linux incluído, seguem uma abordagem semelhante ao referido no ponto anterior. Analisando o exemplo de chamada ao sistema para impressão de uma cadeia de caracteres na consola do capítulo anterior: /*Variáveis globais*/ char msg[]="hello, world!\n"; int len=15; int main() { asm ( "movl len, %edx #comprimento da mensagem \n" "movl $msg, %ecx #ponteiro para mensagem escrever \n" "movl $1, %ebx #descritor do ficheiro ou file handle (stdout)\n" "movl $4, %eax #número da chamada ao sistema (sys_write) \n" "int $0x80 #transfere o controlo para o núcleo ou kernel \n" ); return 0; } Verifica-se que a interrupção que dá acesso aos serviços do Linux é a 80H. No registo EAX é colocado o numero da chamada, ou a função a executar. Nos registos EBX, ECX e EDX são colocados os argumentos. Quando se programa em C é frequente usar as funções definidas na biblioteca libc. Esta biblioteca disponibiliza funções que efectuam muitas das chamadas ao sistema. Este tipo de funções são chamadas de wrappers pois o que fazem é passar os argumentos para registos e chamar a interrupção 80H. O código acima poderia ter sido reescrito substituindo o código assembler simplesmente por: write (1, msg, len); O protótipo de write é: onde: ssize_t write(int fd, const void *buf, size_t count); fd msg len é o descriptor do ficheiro, que é colocado no registo EBX. o ponteiro para mensagem escrever, que é colocado no registo ECX. o comprimento da mensagem, que é colocado no registo EDX. Adicionalmente a função retorna o número de bytes escritos ou -1 em caso de erro. A biblioteca glibc também disponibiliza uma função geral para chamadas ao sistema: syscall (fnc_no, arg1, arg2, ) PIN T03-2/6

3 Onde o primeiro argumento é o número da função da interrupção 80H a executar, e seguidamente os argumentos. Repare-se que fnc_no é sempre colocado no registo EAX, e os argumentos nos registos EBX, ECX, EDX, ESI, EDI e EBP, pela ordem de declaração. Observando a função da libc: write, cujo prótótipo foi apresentado acima verifica-se que os argumentos também seguem a mesma ordem: o primeiro será colocado no registo EBX, o segundo no ECX e assim sucessivamente. Algumas chamadas ao sistema necessitam de mais de 6 argumentos. Neste caso é necessário colocá-los no stack e passar um ponteiro para o bloco de argumentos. Assim poder-se-ía reescrever o exemplo acima ainda de outra forma, substituindo a função write por: syscall (SYS_write, 1, msg, len); /* SYS_write = 4 */ Repare-se que o número da função foi identificado pelo seu nome: write. A correspondência entre os números das funções e os seus nomes está definida em <syscall.h> Passagem de parâmetros locais Se as variáveis do código C a usar no código assembler forem globais, são guardadas num segmento de dados. No entanto se forem locais a uma função ou parâmetros dessa mesma função estão guardadas na pilha do processo. Para simplificar o acesso a estas ultimas variáveis o gcc disponibiliza o mecanismo que se irá apresentar a seguir. Considere-se o exemplo de chamada ao sistema para escrita de uma string num ficheiro, mas onde as variáveis msg e len são locais à função main: int main() { /* Variáveis locais */ char msg[]="hello, world!\n"; int len=15; asm ( "movl %[len], %%edx \n" "movl %[msg], %%ecx \n" "movl $1, %%ebx \n" "movl $4, %%eax \n" "int $0x80 \n" : :[msg]"r"(msg), [len]"r"(len) :"%eax", "%ebx", "%ecx", "%edx" ); return 0; } Repare-se que no fim das instruções assembler existem 3 campos precedidos por dois pontos(:).o primeiro é utilizado para indicar variáveis do código C que poderão ser acedidas para escrita no código assembler, o segundo variáveis do código C que poderão ser acedidas para leitura no código assembler. Finalmente no terceiro campo são indicados os registos usados no código assembler, de modo a preservar o seu conteúdo após a chamada ao segmento de código assembler. PIN T03-3/6

4 No caso do programa acima é apenas necessário ler o conteúdo de variáveis declaradas no código C, sendo usado o segundo campo. A sintaxe é a seguinte: [asmvar] r (cvar) cvar é o identificador da variável no código C, e assmvar é no código assembler. Ambos os identificadores podem ser iguais. No entanto quando usada no código assembler a variável é precedida por um sinal de percentagem e colocada dentro de parênteses rectos: movl %[asmvar], %%eax Além disso os registos são sempre precedidos por dois sinais de percentagem. Para definir variáveis que poderão ser modificadas pelo código assembler a sintaxe é semelhante, mas essa definição deve ser efectuada no primeiro campo: [asmvar] =r (cvar) A única diferença consiste no indicador de acesso à variável que deixa de ser r e passa a ser =r. Neste campo é possível também definir variáveis que poderão ser acedidas para leitura e escrita: [asmvar] +r (cvar) Neste caso o indicador de acesso à variável deverá ser +r. Embora se tenha usado a restrinção r, para que sejam usado registos gerais para passagem de variáveis, como estes são poucos, poder-se-ía ter usado também posições de memória m 3.3 Chamadas ao sistema comuns Uma tabela com as chamadas ao sistema Linux mais comuns encontra-se disponível em: Nesta lista encontram-se acesso ao sistema de ficheiros: open, create, read, write, dup, close, Manipulação de processos: getpid, nice, kill,. Nos próximos capítulos serão abordadas em pormenor algumas chamadas ao sistema. Particularmente interessante é a chamada sysinfo, que permite retornar informação sobre o sistema na estrutura sysinfo, definida em linux/kernel.h: int sysinfo(struct sysinfo *info); Se ocorrer um erro é retornado -1 e a variável errno indica o código de erro. Em caso de sucesso retorna 0. A estrutura sysinfo está definida como: PIN T03-4/6

5 struct sysinfo { long uptime; }; unsigned long loads[3]; /* segundos desde a inicialização do sistema*/ /* media de carga computacional em 1, 5, e 15 minutos*/ unsigned long totalram; /* Capacidade total da memória RAM */ unsigned long freeram; /* Memória RAM livre */ unsigned long sharedram; /* Quantidade de memória partila */ unsigned long bufferram; /* Memória usada pelos buffers do sistema*/ unsigned long totalswap; /* Capacidade da memória virtual (swap) */ unsigned long freeswap; /* Quantidade de memória virtual livre */ unsigned short procs; /* Número de processos */ unsigned long totalhigh; /* Capacidade total da memória alta */ unsigned long freehigh; /* Quantidade de memória alta livre */ unsigned int mem_unit; /* Unidade de memória em bytes */ char _f[20-2*sizeof(long)-sizeof(int)]; /* reservado */ As quantidades acima referidas são apresentadas na unidade especificada pelo campo mem_unit. O seguinte segmento de código permite ler a informação actual do sistema e apresentá-la: #include <linux/kernel.h> int main () { struct sysinfo s_info; int error; error = sysinfo(&s_info); /* imprimir os campos de s_info */ return 0; } 3.4 Acesso a periféricos através de chamadas ao sistema. O exemplo analisado no ponto anterior mostra como se pode escrever uma string num ficheiro, em particular na consola pois o descritor de ficheiro passado como argumento tem o valor de 1, isto é o stdout. Então para escrever a mesma string num ficheiro qualquer basta passar como argumento o descritor do ficheiro que se pretende. Em linux é possível aceder a periféricos como se acede a ficheiros a partir do directório /dev. Por exemplo, se se pretende-se escrever uma string no dispositivo de som ter-se-ía de abrir o ficheiro correspondente /dev/dsp ou /dev/audio, com a funão open da libc, que retorna o descritor do ficheiro, e usar esse descritor na chamada write. Claro que o som emitido não corresponderia ao conteúdo semântico da string. As funções da libc que permitem abrir, criar e fechar ficheiros: open, create e close são também wrappers para chamadas ao sistema. Neste caso têm-se a seguinte decomposição em camadas: Libc Chamada ao sistema Kernel: Sistema de ficheiros open(), create(),close() int 80H executam OPEN CREATE CLOSE PIN T03-5/6

6 No nível superior têm-se as funções da libc, que simplesmente passam os argumentos para registos do CPU e invocam a interrupção 80H, isto é efectuam uma chamada ao sistema. O controlo é então passado de um processo de utilizador para o kernel. Neste caso o kernel, mais precisamente o sistema de ficheiros, efectuará a operação, no caso de OPEN ou CREATE. e retorna um descritor de ficheiro. Este descritor é um inteiro positivo e indica uma entrada numa tabela a partir da qual é possível identificar a que dispositivo se refere o ficheiro. Aberto o ficheiro é possível escrever ou ler deste. De modo que a operação seja independente do dispositivo de E/S, o sistema de ficheiros acede à operação write implementada pelo driver adequado, que se encarregará da transferência de dados entre o processo de utilizador e o dispositivo ou periférico. Espaço Nível Processo utilizador write (1, msg, len) syscall (write, 1, msg, len) utilizador Kernel Libc Sistema de ficheiros device driver movl len, %edx #Passagem dos argumentos movl $msg, %ecx #da função libc para os movl $1, %ebx #registos do CPU movl $4, %eax int 0x80 #Chamada ao sistema acede à operação write implementada pelo driver adequado Transfere a informação pretendida com o processo, acedendo directamente aos registos do controlador Fig. 3-1: Acesso a periféricos usando chamadas ao sistema 3.5 Bibliografia Salzman, Peter Jay, Michael Burian and Ori Pomerantz (2005). The Linux Kernel Module Programming Guide, Páginas do manual Linux (man pages), em particular: man 2 intro, man 2 syscall, man 2 sysinfo. Lista de chamadas ao sistema: Manual gcc: em particular as extensões de Assembler embebido em C: - Extended-Asm PIN T03-6/6