Seja Elegante

Talvez possa ser algo que passe despercebido por vários desenvolvedores, porém dúvido quem nunca tenha se deparado com mensagens de “log” vagas ou sem nenhum nexo ou bem pior, como mensagens idênticas replicadas por várias partes do código!
A algum tempo atrás estava trabalhando em um projeto em que um respectivo desenvolvedor da equipe possuia o costume de espalhar ou replicar centenas de printf() pelo código com mensagens tipo!

printf(“!!! FULANO – Aqui!!!”);

ou

printf(“!!! FULANO – Arquivo.cpp:  Aqui!!!\n”);

Precisa falar que isto e pessímo? Certo que e preciso um bom senso com o uso de mensagens de depuração pois dependendo ao invés de ajudar podem só atrapalhar. principalmente quando você necessita ter controle sobre tais mensagens, como por exemplo obter a localização da mensagem através do nome da função, arquivo e linha.

O pré-processador do GCC oferece (*) várias macros, as que irei utilizar em questão são:

• __FILE__ : Substituída pelo nome do arquivo.
• __PRETTY_FUNCTION__ : Substituídas pelo nome nome da função.
• __LINE__ : Substituída pelo número da linha de código.

(*) Mais detalhes sobre as macros do GCC.

A utilização dessas macros irá facilitar a localização das mensagens de depuração, Abaixo um simples exemplo demonstrado em debug1.c.

/**
 * By Jorge Pereira <jpereiran@gmail.com>
 * Date: Tue Jun 29 02:51:44 BRT 2010
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

// Macro condicional
#ifdef DEBUG
#	warning "Debug is enabled"
#	define TRACE_DEBUG(fmt, ...) \
	fprintf(stderr, " ** DEBUG: %s:%d %s(): "fmt"\n", \
	__FILE__, __LINE__, __PRETTY_FUNCTION__, ##__VA_ARGS__)
#else
#	warning "Debug is disabled"
#	define TRACE_DEBUG(fmt, ...)
#endif

#define MAX_STRING 5 /* tamanho maximo de uma string */

// Função simples de exemplo...
void
show_name (const char* name,
		   size_t len)
{
	size_t offset = len;

	// Verificação qualquer...
	if (len > MAX_STRING)
	{
		// Abaixo mensagem de depuração, perceba que ela será ativada apenas
                // quando em tempo de compilação você ativar a macro "DEBUG"
		TRACE_DEBUG ("Ooops! Tamanho da string(%d) e excedeu o limite(%d)...",
			len, MAX_STRING);
		offset = MAX_STRING;
	}

	// Manipulação qualquer...
	write (STDOUT_FILENO, name, offset);
	write (STDOUT_FILENO, "\n", 1);
}

int
main (int argc, char* argv[])
{
	if (argc < 2)
	{
		printf ("Usage: %s <string>\n", argv[0]);
		exit (1);
	}

	show_name (argv[1], strlen (argv[1]));

	return 0;
}

Com este exemplo básico em mãos, vamos compilar e executar.

[jpereira@miracleworld Codes]$ gcc -Wall -o debug1 debug1.c
debug1.c:18:3: warning: #warning "Debug is disabled"
[jpereira@miracleworld Codes]$ ./debug1 "Jorge"
Jorge
[jpereira@miracleworld Codes]$ ./debug1 "Jorge Pereira"
Jorge
[jpereira@miracleworld Codes]$

Imagine que seu sistema possui inúmeros arquivos e você precisa em determinados pontos obter o máximo de informação sobre as mensagens de depuração, talvez seja interessante ter além de uma mensagem objetiva obter juntamente o nome da função, arquivo e linha de onde foi invocada tal mensagem.

[jpereira@miracleworld Codes]$ gcc -Wall -DDEBUG -o debug1 debug1.c
debug1.c:13:3: warning: #warning "Debug is enabled"
[jpereira@miracleworld Codes]$ ./debug1 "Jorge"
Jorge
[jpereira@miracleworld Codes]$ ./debug1 "Jorge Pereira"
 ** DEBUG: debug1.c:36 show_name(): Ooops! Tamanho da string(13) e excedeu o limite(5)...
Jorge
[jpereira@miracleworld Codes]$

Lembrando que este e o primeiro post entre vários que pretendo publicar relacionados a sugestões e técnicas de depuração. Fique de olho na segunda parte desta saga em que irei explicar uma mais dinâmica do mesmo assunto abordado neste post associando ao uso de variáveis de ambiente.
Dúvidas e Sugestões, são sempre bem vindas!

Autor: Jorge Pereira

O que acontece basicamente e que o linker dinâmico do Linux (assim como em tantos outros sistemas operacionais) utiliza diversas formas, alguma delas sendo através de variáveis de ambiente para controlar seu comportamento. Sendo que neste caso a variável LD_PRELOAD informa ao linker dinâmico que carregue as bibliotecas listadas nela antes de carregar quaisquer outras bibliotecas necessárias, enquando LD_LIBRARY_PATH especifica um caminho alternativo para usar ao procurar bibliotecas que serão carregadas.

Partindo deste principio podemos fazer com que um programa a ser executado seja “hijacked” por outro programa, ou seja. Podemos fazer por exemplo que a função hehe() previamente chamada pelo programa “A” tenha seu comportamento alterado sem precisar fazer quaisquer alteração no programa “A”. Um pouco complexo? talvez! Mais vamos por a mão na massa! hands on!

Digamos que você tem o programa “main” conforme o código de exemplo abaixo, perceba que o código e super simples. apenas declaro um ponteiro de caracteres, aloco memória e em seguida copio uma sequência de caracteres para o ponteiro previamente alocado. Simples, certo?

1) Abaixo código de exemplo de nosso “main.c” ou clique aqui para download.

/*
 *  Filename: hijack_main.c
 *  Created: Wed Jun  9 22:11:12 BRT 2010
 *  Author: Jorge Pereira <jpereiran@gmail.com>
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int
main (int argc,
      char* argv[])
{
  char* nome = (char*)malloc (100);

  strcpy (nome, "Jorge Pereira");
  printf ("NOME: %s\n", nome);

  free (nome);
  return 0;
}

# Vamos compilar e executar o nosso exemplo “main.c”

$ gcc -Wall -o main main.c
$ ./main
NOME: Jorge Pereira
$

Até aqui tudo bem, porém imagine você em uma determinada situação em que precisa saber quantos bytes está sendo alocado por um determinado programa? e você por alguns instantes imagina sobre a possibilidade de poder fazer algum tipo de “overload” de uma determinada função na qual você conhece sua assinatura. (Digamos, você sabe a assinatura do método, quantidade e tipos dos parâmetros, …).

Pois bem, neste exemplo que irei demonstrar será para sobrecarregar todas as chamadas feitas pelo meu programa “main” às funções malloc() e free() e em seguida exibir uma mensagem no caso do malloc() imprimindo seu parâmetro que e o tamanho de bytes alocados, e na função free() exibindo os ponteiros que foram liberados.

Neste caso, iremos criar uma biblioteca chamada “libhijack_hehe.so” que será carregada através da variável mágica LD_PRELOAD em parceria com nosso querido linker dinâmico.

2) Abaixo código de exemplo de “hijack_hehe.c“, ou clique aqui para download.

/*
 *  Filename: hijack_hehe.c
 *  Created: Wed Jun  9 22:11:12 BRT 2010
 *  Author: Jorge Pereira <jpereiran@gmail.com>
 */
#define _GNU_SOURCE
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

#include <dlfcn.h>

#define HIJACK_DEBUG(fmt, ...) \
	fprintf(stderr, " ** DEBUG: %s:%d %s(): "fmt"\n", \
	__FILE__, __LINE__, __PRETTY_FUNCTION__, ##__VA_ARGS__)

static void* (*hack_malloc)(size_t size) = NULL;
static void  (*hack_free)(void *p) = NULL;

static void* rest_malloc = NULL;

void*
malloc (size_t size)
{
  if (hack_malloc == NULL)
  {
    hack_malloc = (void *(*)(size_t)) dlsym (RTLD_NEXT, "malloc");
    rest_malloc = NULL;
  }

  if (rest_malloc == NULL)
  {
    rest_malloc = hack_malloc (size);
    HIJACK_DEBUG ("Alocando (%d) bytes, chunck(%p)", size, (void*)rest_malloc);
    return rest_malloc;
  }

  hack_malloc = NULL;
  return rest_malloc;
}

void
free (void *p)
{
	HIJACK_DEBUG ("Desalocando (%p)", p);

  if (hack_free == NULL)
  {
    hack_free = (void (*)(void *)) dlsym(RTLD_NEXT, "free");
  }

  hack_free (p);
}

Agora vamos compilar, executar e analisar o comportamento.

$ gcc -Wall -shared -ldl -o libhijack_hehe.so hijack_hehe.c
$ LD_PRELOAD=./libhijack_hehe.so ./main
 ** DEBUG: hijack_hehe.c:35 malloc(): Alocando (100) bytes, chunck(0x9273008)
NOME: Jorge Pereira
 ** DEBUG: hijack_hehe.c:46 free(): Desalocando (0x9273008)
$

Percebeu algo diferente na execução com a LD_PRELOAD passando como parâmetro a nossa libhijack_hehe.so? pois bem, todas as chamadas às funções malloc() e free() foram sobrecarregadas e passaram a se comportar conforme as versões que escrevi em hijack_hehe.c. Caso tenha ficado curioso, e so re-escrever tais exemplos com outras funções que você deseja sobrecarregar e ver o comportamento. Lembrando que basta utilizar a criatividade e perceberá na quantidade de coisas que podem ser feita com tal técnica.

Exemplo: Nas funções que fazem checagem com strcmp(), uso da crypt(), … entre outras.

Referências

• man 8 ld.so

Autor: Jorge Pereira
Data: Wed Jun 9 23:42:26 BRT 2010

1) Devemos utilizar a variável de ambiente LD_DEBUG, primeiramente iremos utilizar passando o parâmetro help para em seguida utilizar de acordo com a necessidade!

[root@jiraya ~]# export LD_DEBUG=help
[root@jiraya ~]# ls
Valid options for the LD_DEBUG environment variable are:

libs        display library search paths
reloc       display relocation processing
files       display progress for input file
symbols     display symbol table processing
bindings    display information about symbol binding
versions    display version dependencies
all         all previous options combined
statistics  display relocation statistics
unused      determined unused DSOs
help        display this help message and exit

To direct the debugging output into a file instead of standard output
a filename can be specified using the LD_DEBUG_OUTPUT environment variable.
[root@localhost ~]# export LD_DEBUG=libs
[root@localhost ~]# ls
5957:     find library=librt.so.1 [0]; searching
5957:      search cache=/etc/ld.so.cache
5957:       trying file=/lib/i686/librt.so.1
5957:
5957:     find library=libacl.so.1 [0]; searching
5957:      search cache=/etc/ld.so.cache
5957:       trying file=/lib/libacl.so.1
5957:
5957:     find library=libc.so.6 [0]; searching
5957:      search cache=/etc/ld.so.cache
5957:       trying file=/lib/i686/libc.so.6
5957:
5957:     find library=libpthread.so.0 [0]; searching
5957:      search cache=/etc/ld.so.cache
5957:       trying file=/lib/i686/libpthread.so.0
5957:
5957:     find library=libattr.so.1 [0]; searching
5957:      search cache=/etc/ld.so.cache
5957:       trying file=/lib/libattr.so.1
5957:
5957:
5957:     calling init: /lib/i686/libpthread.so.0
5957:
5957:
5957:     calling init: /lib/i686/libc.so.6
5957:
5957:
5957:     calling init: /lib/libattr.so.1
5957:
5957:
5957:     calling init: /lib/libacl.so.1
5957:
5957:
5957:     calling init: /lib/i686/librt.so.1
5957:
5957:
5957:     initialize program: ls
5957:
5957:
5957:     transferring control: ls
5957:
5957:     find library=libnss_files.so.2 [0]; searching
5957:      search cache=/etc/ld.so.cache
5957:       trying file=/lib/libnss_files.so.2
5957:
5957:
5957:     calling init: /lib/libnss_files.so.2
5957:
bin  get  hdparm.sh  he  he.c  seeker  src  tmp
[root@localhost ~]#

2) Caso queira enviar a saída da depuração para um arquivo, basta utilizar a variável de ambiente LD_DEBUG_OUTPUT, abaixo um exemplo de uma depuração completa com o modo all seguido de toda saída sendo enviada para o arquivo ls-debug-calls.log

[root@jiraya ~]# export LD_DEBUG_OUTPUT=ls-debug-calls.log
[root@jiraya ~]# export LD_DEBUG=all
[root@jiraya ~]# ls

3) Para desativar, basta simplesmente remover a variável de ambiente LD_DEBUG e se for o caso também a LD_DEBUG_OUTPUT

[root@jiraya ~]# unset LD_DEBUG
[root@jiraya ~]# unset LD_DEBUG_OUTPUT
[root@jiraya ~]# ls

Mais informações podem ser encontradas em Program-Library-HOWTO

Acredito que todos que trabalham com desenvolvimento utilizando o Linux, já precisaram depurar algum trecho de código, e todos sabem que para quem não tem muito costume ele não e muito “amigável”. então segue abaixo link com tutorial e alguns arquivos de configuração contendo atalhos entre outras funções que com certeza irá ajudar muito na hora de depurar.

Abaixo segue alguns exemplos de configuração do GDB, lembrando que deverá ser salvo em ~/.gdbinit, caso queira ter como configuração padrão. do contrário basta utilizar o gdb passando o parâmetro -command,

Ex: gdb -command=gdbinit.txt

• http://www.kernsh.org/repo/gdbinit.txt
• http://tinderbox.x86.dev.gentoo.org/misc/dot.gdbinit
• http://dotfiles.org/~mkfs/.gdbinit

Excelentes tutoriais sobre GDB

• http://www.linuxtopia.org/online_books/redhat_linux_debugging_with_gdb/
• http://www.dirac.org/linux/gdb/
• http://www.arl.wustl.edu/~fredk/Courses/Docs/gdb.pdf
• http://www.arl.wustl.edu/~fredk/Courses/Docs/gdb_refcard.pdf
• http://www.arl.wustl.edu/~fredk/Courses/Docs/gdbint.pdf