Exemplos do uso syscalls (x86) do Linux

Tiago Maluta — Wed, 21 Jan 2009 00:36:35 +0000

Hoje tive uma idéia ao ler um artigo intitulado How Compiling Works no qual o autor descreve em linhas gerais, mas de uma maneira interessante, o processo de compilação de um código escrito em C (abordando o processo de linkagem com as bibliotecas) tomando como exemplo a função printf. Resolvi fazer uma brincadeira, mostrando como isso pode ser realmente implementado na prática, usando chamadas de sistema (syscalls) do Linux, de modo que não seja necessário usar a implementação disponível na glibc.

Começando com um exemplo simples, bem parecido com que todo mundo que um dia pensou em programar já viu. A diferença que a função printf será modificada para receber apenas caracteres (não variáveis) e a quantidade.

#include "stdio.h"
int main() {

	printf("Hello, world!\n",15);
	return 0;
}

Reparem que o cabeçalho está entre aspas, indicando ao compilador que vamos usar uma implementação particular e não a implementação da glibc, no meu caso os arquivos

/usr/include/stdio.h (protótipo)
/usr/lib/libc.so (implementação)

Serão substituidos pelos arquivos stdio.h e stdio.c abaixo:

#ifndef STDIO_H_
#define STDIO_H_

int printf(char* texto, int tam);

#endif /* STDIO_H_ */

Agora que temos o protótipo da função printf() que é diferente da função printf() que conhecemos mas servirá para esse primeiro exemplo:

#include "stdio.h"

int printf(char* texto, int tam)

{
__asm__ ("movl $0x4,%%eax; \
          movl $0x1,%%ebx; \
          movl %0,%%ecx; \
          movl %1,%%edx; \
          int $0x80": : "g" (texto) , "g" (tam) );

  return 0;
}

Podemos incrementar um pouco mais do código em assembly, para não precisar estipular o número de caracteres.

__asm__ ("      xorl %%edx,%%edx; \
                xorl %%eax,%%eax; \

                movl %0,%%ecx; \
        loop:   movb (%%ecx,%%edx),%%al; \
                incl %%edx; \
                test %%al,%%al; \
                jnz loop; \
                decl %%edx; \

                movl $0x4,%%eax; \
                movl $0x1,%%ebx; \
                int $0x80": : "g" (texto));

Para fazer uma função equivalente ao printf() da glibc precisaríamos implementar o suporte a múltiplos argumentos e mais um monte de coisas Fiz um esboço de uma idéia do printf, mas ainda usando funções da glibc apenas implementando a syscall write.

#include 
#include 
#include 

#define _write(texto, d) 
__asm__ ("movl $0x4,%%eax; \
	  movl $0x1,%%ebx; \
	  movl %0,%%ecx; \
	  movl %1,%%edx; \

	  int $0x80": : "g" (texto) , "g" (d) );

int write(char *fmt, ...);

int main(){

	char *index=malloc(2);
	char *nome=malloc(20);

	strcpy(index,"19");
	strcpy(nome,"Escovando Bits !!!");

	write("blog: %s \nindex: %s\n",nome,index);

	return 0;
}

int write(char *fmt, ...) {

	char *s;
	va_list ap;
	register int d=0,tam;

	int size;

	va_start(ap, fmt );
	tam = strlen(fmt);

	for (d=0; d

		if (*fmt != '%' ) {

		_write(fmt,1);
		} else {

			switch (*++fmt) {
			case 's': {
				s = va_arg(ap, char *);

				size = strlen(s);
				_write(s,size);
			break;
			} // fim case
			} // fim switch

		} // fim else
	} // fim for

	va_end(ap);
	return(1);
}

Se analisarmos o código-fonte da glibc veremos que sua implementação é completamente diferente da proposta nesse post, por questões de portabilidade de hardware, segurança, elegância, desempenho, etc; Um exemplo é a possiblidade de criar extensões para a função printf.

Bom, essa foi a primeira entrada do ano aqui no EscovandoBits, mais novidades para os próximos dias, com a cobertura do Mauro sobre a Campus Party que acontece do dia 19 a 25 de Janeiro.

Posted in programação Tagged: c, glibc, kernel, Linux, syscalls

Lguest: um hypervisor didático

Tiago Maluta — Mon, 27 Oct 2008 22:19:29 +0000

“If unsure, say N. If curious, say M. If masochistic, say Y “

(Linux kernel config for lguest module)

Um hypervisor é uma máquina virtual monitora (virtual machine monitor) que possibilita executar diversos sistemas operacionais em uma mesma máquina. Isso significa que você pode executar o Windows e o OpenBSD em máquinas virtuais executando em cima do Gentoo, Fedora, ou outra plataforma GNU/Linux.

Exemplos

No kernel existem pelo menos 8 sistema de virtualização distintos: Xen, KVM, VMWares’s VMI, IBM’s System p, IBM’s System z, User Mode Linux, lguest e IBM’s legacy iSeries.

O que é o lguest ?

O projeto lguest, desenvolvido por Rusty Russel, do iptables, é um projeto simples de virtualização. Este permite a virtualização completa de kernels. Atualmente, apenas o kernel Linux é suportado como convidado (guest) e somente em hardware x86 (32bits).

Utilização: instalação

A primeira coisa a fazer é ler a documentação oficial lguest.txt. Não se esqueça de ativar o .config as seguintes opções:

.
CONFIG_EXPERIMENTAL=y
CONFIG_PARAVIRT=y
CONFIG_LGUEST_GUEST=y
CONFIG_HIGHMEM64G=n
CONFIG_PHYSICAL_ALIGN=0x100000
CONFIG_VIRTIO_BLK=m
CONFIG_VIRTIO_NET=m
CONFIG_TUN=m
CONFIG_LGUEST=m

Utilização: executando

Depois de compilar o kernel, carrege os módulos lg e tun e dê um make dentro do diretório Documentation/lguest/ para compilar uma ferramenta chamada lguest que será utilzada para iniciar o lguest. Depois para rodar:

Documentation/lguest/lguest 128 vmlinux –tunnet=192.168.254.10 –block=rootfile root=/dev/vda

Algumas explicações:

vmlinux: a imagem do kernel (pode-se utilizar também o bzImage)
rootfile: Para ter o mínimo de usabilidade, você precisa testar o kernel em cima de algum sistema de arquivos. Uma maneira rápida para testar é usar um ramdisk, clique no rootfile acima para baixar a imagem a substitua pelo nome do arquivo (initrd-1.1-i386.img).
tunnet: configura um dispositivo “tap”
root=/dev/vda parâmetros do kernel (pode ser qualquer opção compatível como parâmetro do kernel)

Na documentação há ensinado como utilizar uma distribuição (a partir de uma ISO) com o qemu para trabalhos mais sérios.

Dica: acesso via NFS

Em vez de ficar criando uma imagem ou mesmo usando o qemu eu acho que é mais rápido montar uma partição via NFS e usá-la para acessar os arquivos.

Documentation/lguest/lguest –tunnet= vmlinux ip=:::::: nfsroot=:/caminho/para/rootfs root=/dev/nfs

No meu caso eu uso uma variação nos pacotes do stage3 do Gentoo.

E o didático dessa história?

O lguest possui um Quest (dividido em 7 partes) bem interessante para quem quer entender o funcionamento de um virtualizador vendo o “código”, acessem do diretório drivers/lguest/README no código-fonte do kernel para saber como começar.

Referências

http://lguest.ozlabs.org/

http://en.wikipedia.org/wiki/Hypervisor

http://lwn.net/Articles/218766/

Posted in Linux Tagged: kernel, lguest, Linux, virtualização

.::Escovando Bits::. » kernel

Exemplos do uso syscalls (x86) do Linux

Lguest: um hypervisor didático